]> 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_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTIFFHandler swig_types[124]
2591 #define SWIGTYPE_p_wxToolTip swig_types[125]
2592 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[126]
2593 #define SWIGTYPE_p_wxValidator swig_types[127]
2594 #define SWIGTYPE_p_wxVisualAttributes swig_types[128]
2595 #define SWIGTYPE_p_wxWindow swig_types[129]
2596 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[130]
2597 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[131]
2598 #define SWIGTYPE_p_wxXPMHandler swig_types[132]
2599 #define SWIGTYPE_p_wxZipFSHandler swig_types[133]
2600 static swig_type_info *swig_types[135];
2601 static swig_module_info swig_module = {swig_types, 134, 0, 0, 0, 0};
2602 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2603 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2604
2605 /* -------- TYPES TABLE (END) -------- */
2606
2607 #if (PY_VERSION_HEX <= 0x02000000)
2608 # if !defined(SWIG_PYTHON_CLASSIC)
2609 # error "This python version requires to use swig with the '-classic' option"
2610 # endif
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodern' option"
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodernargs' option"
2617 #endif
2618 #ifndef METH_O
2619 # error "This python version requires to use swig with the '-nofastunpack' option"
2620 #endif
2621
2622 /*-----------------------------------------------
2623 @(target):= _core_.so
2624 ------------------------------------------------*/
2625 #define SWIG_init init_core_
2626
2627 #define SWIG_name "_core_"
2628
2629 #define SWIGVERSION 0x010329
2630
2631
2632 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2633 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2634
2635
2636 #include <stdexcept>
2637
2638
2639 namespace swig {
2640 class PyObject_ptr {
2641 protected:
2642 PyObject *_obj;
2643
2644 public:
2645 PyObject_ptr() :_obj(0)
2646 {
2647 }
2648
2649 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2650 {
2651 Py_XINCREF(_obj);
2652 }
2653
2654 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2655 {
2656 if (initial_ref) Py_XINCREF(_obj);
2657 }
2658
2659 PyObject_ptr & operator=(const PyObject_ptr& item)
2660 {
2661 Py_XINCREF(item._obj);
2662 Py_XDECREF(_obj);
2663 _obj = item._obj;
2664 return *this;
2665 }
2666
2667 ~PyObject_ptr()
2668 {
2669 Py_XDECREF(_obj);
2670 }
2671
2672 operator PyObject *() const
2673 {
2674 return _obj;
2675 }
2676
2677 PyObject *operator->() const
2678 {
2679 return _obj;
2680 }
2681 };
2682 }
2683
2684
2685 namespace swig {
2686 struct PyObject_var : PyObject_ptr {
2687 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2688
2689 PyObject_var & operator = (PyObject* obj)
2690 {
2691 Py_XDECREF(_obj);
2692 _obj = obj;
2693 return *this;
2694 }
2695 };
2696 }
2697
2698
2699 #include "wx/wxPython/wxPython_int.h"
2700 #include "wx/wxPython/pyclasses.h"
2701 #include "wx/wxPython/twoitem.h"
2702
2703
2704 #ifndef wxPyUSE_EXPORT
2705 // Helper functions for dealing with SWIG objects and such. These are
2706 // located here so they know about the SWIG types and functions declared
2707 // in the wrapper code.
2708
2709 #include <wx/hashmap.h>
2710 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2711
2712
2713 // Maintains a hashmap of className to swig_type_info pointers. Given the
2714 // name of a class either looks up the type info in the cache, or scans the
2715 // SWIG tables for it.
2716 extern PyObject* wxPyPtrTypeMap;
2717 static
2718 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2719
2720 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2721
2722 if (typeInfoCache == NULL)
2723 typeInfoCache = new wxPyTypeInfoHashMap;
2724
2725 wxString name(className);
2726 swig_type_info* swigType = (*typeInfoCache)[name];
2727
2728 if (! swigType) {
2729 // it wasn't in the cache, so look it up from SWIG
2730 name.Append(wxT(" *"));
2731 swigType = SWIG_TypeQuery(name.mb_str());
2732
2733 // if it still wasn't found, try looking for a mapped name
2734 if (!swigType) {
2735 PyObject* item;
2736 name = className;
2737
2738 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2739 (char*)(const char*)name.mbc_str())) != NULL) {
2740 name = wxString(PyString_AsString(item), *wxConvCurrent);
2741 name.Append(wxT(" *"));
2742 swigType = SWIG_TypeQuery(name.mb_str());
2743 }
2744 }
2745 if (swigType) {
2746 // and add it to the map if found
2747 (*typeInfoCache)[className] = swigType;
2748 }
2749 }
2750 return swigType;
2751 }
2752
2753
2754 // Check if a class name is a type known to SWIG
2755 bool wxPyCheckSwigType(const wxChar* className) {
2756
2757 swig_type_info* swigType = wxPyFindSwigType(className);
2758 return swigType != NULL;
2759 }
2760
2761
2762 // Given a pointer to a C++ object and a class name, construct a Python proxy
2763 // object for it.
2764 PyObject* wxPyConstructObject(void* ptr,
2765 const wxChar* className,
2766 int setThisOwn) {
2767
2768 swig_type_info* swigType = wxPyFindSwigType(className);
2769 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2770
2771 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2772 }
2773
2774
2775 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2776 // Ensures that the proxy object is of the specified (or derived) type. If
2777 // not able to perform the conversion then a Python exception is set and the
2778 // error should be handled properly in the caller. Returns True on success.
2779 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2780 const wxChar* className) {
2781
2782 swig_type_info* swigType = wxPyFindSwigType(className);
2783 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2784
2785 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2786 }
2787
2788
2789
2790 // Make a SWIGified pointer object suitable for a .this attribute
2791 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2792
2793 PyObject* robj = NULL;
2794
2795 swig_type_info* swigType = wxPyFindSwigType(className);
2796 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2797
2798 robj = PySwigObject_New(ptr, swigType, 0);
2799 return robj;
2800 }
2801
2802
2803 // Python's PyInstance_Check does not return True for instances of new-style
2804 // classes. This should get close enough for both new and old classes but I
2805 // should re-evaluate the need for doing instance checks...
2806 bool wxPyInstance_Check(PyObject* obj) {
2807 return PyObject_HasAttrString(obj, "__class__") != 0;
2808 }
2809
2810
2811 // This one checks if the object is an instance of a SWIG proxy class (it has
2812 // a .this attribute, and the .this attribute is a PySwigObject.)
2813 bool wxPySwigInstance_Check(PyObject* obj) {
2814 static PyObject* this_str = NULL;
2815 if (this_str == NULL)
2816 this_str = PyString_FromString("this");
2817
2818 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2819 if (this_attr) {
2820 bool retval = (PySwigObject_Check(this_attr) != 0);
2821 Py_DECREF(this_attr);
2822 return retval;
2823 }
2824
2825 PyErr_Clear();
2826 return false;
2827 }
2828
2829
2830 // Export a C API in a struct. Other modules will be able to load this from
2831 // the wx._core_ module and will then have safe access to these functions,
2832 // even if they are located in another shared library.
2833 static wxPyCoreAPI API = {
2834
2835 wxPyCheckSwigType,
2836 wxPyConstructObject,
2837 wxPyConvertSwigPtr,
2838 wxPyMakeSwigPtr,
2839
2840 wxPyBeginAllowThreads,
2841 wxPyEndAllowThreads,
2842 wxPyBeginBlockThreads,
2843 wxPyEndBlockThreads,
2844
2845 wxPy_ConvertList,
2846
2847 wxString_in_helper,
2848 Py2wxString,
2849 wx2PyString,
2850
2851 byte_LIST_helper,
2852 int_LIST_helper,
2853 long_LIST_helper,
2854 string_LIST_helper,
2855 wxPoint_LIST_helper,
2856 wxBitmap_LIST_helper,
2857 wxString_LIST_helper,
2858 wxAcceleratorEntry_LIST_helper,
2859
2860 wxSize_helper,
2861 wxPoint_helper,
2862 wxRealPoint_helper,
2863 wxRect_helper,
2864 wxColour_helper,
2865 wxPoint2D_helper,
2866
2867 wxPySimple_typecheck,
2868 wxColour_typecheck,
2869
2870 wxPyCBH_setCallbackInfo,
2871 wxPyCBH_findCallback,
2872 wxPyCBH_callCallback,
2873 wxPyCBH_callCallbackObj,
2874 wxPyCBH_delete,
2875
2876 wxPyMake_wxObject,
2877 wxPyMake_wxSizer,
2878 wxPyPtrTypeMap_Add,
2879 wxPy2int_seq_helper,
2880 wxPy4int_seq_helper,
2881 wxArrayString2PyList_helper,
2882 wxArrayInt2PyList_helper,
2883
2884 wxPyClientData_dtor,
2885 wxPyUserData_dtor,
2886 wxPyOORClientData_dtor,
2887
2888 wxPyCBInputStream_create,
2889 wxPyCBInputStream_copy,
2890
2891 wxPyInstance_Check,
2892 wxPySwigInstance_Check,
2893
2894 wxPyCheckForApp,
2895
2896 wxArrayDouble2PyList_helper,
2897 wxPoint2D_LIST_helper,
2898 wxRect2D_helper,
2899
2900 };
2901
2902 #endif
2903
2904
2905 #if !WXWIN_COMPATIBILITY_2_4
2906 #define wxHIDE_READONLY 0
2907 #endif
2908
2909
2910 #define SWIG_From_long PyInt_FromLong
2911
2912
2913 SWIGINTERNINLINE PyObject *
2914 SWIG_From_int (int value)
2915 {
2916 return SWIG_From_long (value);
2917 }
2918
2919 static const wxString wxPyEmptyString(wxEmptyString);
2920 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2921 return self->GetClassInfo()->GetClassName();
2922 }
2923 SWIGINTERN void wxObject_Destroy(wxObject *self){
2924 delete self;
2925 }
2926
2927 #ifndef __WXMAC__
2928 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2929 #endif
2930
2931
2932 #include <limits.h>
2933 #ifndef LLONG_MIN
2934 # define LLONG_MIN LONG_LONG_MIN
2935 #endif
2936 #ifndef LLONG_MAX
2937 # define LLONG_MAX LONG_LONG_MAX
2938 #endif
2939 #ifndef ULLONG_MAX
2940 # define ULLONG_MAX ULONG_LONG_MAX
2941 #endif
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_long (PyObject* obj, long* val)
2946 {
2947 if (PyNumber_Check(obj)) {
2948 if (val) *val = PyInt_AsLong(obj);
2949 return SWIG_OK;
2950 }
2951 return SWIG_TypeError;
2952 }
2953
2954
2955 SWIGINTERN int
2956 SWIG_AsVal_int (PyObject * obj, int *val)
2957 {
2958 long v;
2959 int res = SWIG_AsVal_long (obj, &v);
2960 if (SWIG_IsOK(res)) {
2961 if ((v < INT_MIN || v > INT_MAX)) {
2962 return SWIG_OverflowError;
2963 } else {
2964 if (val) *val = static_cast< int >(v);
2965 }
2966 }
2967 return res;
2968 }
2969
2970 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2971 wxSize temp, *obj = &temp;
2972 if ( other == Py_None ) return false;
2973 if ( ! wxSize_helper(other, &obj) ) {
2974 PyErr_Clear();
2975 return false;
2976 }
2977 return self->operator==(*obj);
2978 }
2979 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2980 wxSize temp, *obj = &temp;
2981 if ( other == Py_None ) return true;
2982 if ( ! wxSize_helper(other, &obj)) {
2983 PyErr_Clear();
2984 return true;
2985 }
2986 return self->operator!=(*obj);
2987 }
2988
2989 #include <float.h>
2990
2991
2992 SWIGINTERN int
2993 SWIG_AsVal_double (PyObject *obj, double* val)
2994 {
2995 if (PyNumber_Check(obj)) {
2996 if (val) *val = PyFloat_AsDouble(obj);
2997 return SWIG_OK;
2998 }
2999 return SWIG_TypeError;
3000 }
3001
3002
3003 SWIGINTERN int
3004 SWIG_AsVal_float (PyObject * obj, float *val)
3005 {
3006 double v;
3007 int res = SWIG_AsVal_double (obj, &v);
3008 if (SWIG_IsOK(res)) {
3009 if ((v < -FLT_MAX || v > FLT_MAX)) {
3010 return SWIG_OverflowError;
3011 } else {
3012 if (val) *val = static_cast< float >(v);
3013 }
3014 }
3015 return res;
3016 }
3017
3018 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3019 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3023 //wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026
3027 #define SWIG_From_double PyFloat_FromDouble
3028
3029 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3030 wxRealPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxRealPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3039 wxRealPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxRealPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3052 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3056 //PyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3060 wxPoint temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxPoint_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3069 wxPoint temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxPoint_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3078 self->x = x;
3079 self->y = y;
3080 }
3081 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3082 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 PyObject* tup = PyTuple_New(2);
3084 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3085 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3086 //wxPyEndBlockThreads(blocked);
3087 return tup;
3088 }
3089 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3090 wxRect temp, *obj = &temp;
3091 if ( other == Py_None ) return false;
3092 if ( ! wxRect_helper(other, &obj) ) {
3093 PyErr_Clear();
3094 return false;
3095 }
3096 return self->operator==(*obj);
3097 }
3098 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3099 wxRect temp, *obj = &temp;
3100 if ( other == Py_None ) return true;
3101 if ( ! wxRect_helper(other, &obj)) {
3102 PyErr_Clear();
3103 return true;
3104 }
3105 return self->operator!=(*obj);
3106 }
3107 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3108 self->x = x;
3109 self->y = y;
3110 self->width = width;
3111 self->height = height;
3112 }
3113 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3114 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3115 PyObject* tup = PyTuple_New(4);
3116 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3117 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3118 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3119 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3120 //wxPyEndBlockThreads(blocked);
3121 return tup;
3122 }
3123
3124 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3125 wxRegion reg1(*r1);
3126 wxRegion reg2(*r2);
3127 wxRect dest(0,0,0,0);
3128 PyObject* obj;
3129
3130 reg1.Intersect(reg2);
3131 dest = reg1.GetBox();
3132
3133 if (dest != wxRect(0,0,0,0)) {
3134 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 wxRect* newRect = new wxRect(dest);
3136 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3137 //wxPyEndBlockThreads(blocked);
3138 return obj;
3139 }
3140 Py_INCREF(Py_None);
3141 return Py_None;
3142 }
3143
3144 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3145 wxPoint2D temp, *obj = &temp;
3146 if ( other == Py_None ) return false;
3147 if ( ! wxPoint2D_helper(other, &obj) ) {
3148 PyErr_Clear();
3149 return false;
3150 }
3151 return self->operator==(*obj);
3152 }
3153 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3154 wxPoint2D temp, *obj = &temp;
3155 if ( other == Py_None ) return true;
3156 if ( ! wxPoint2D_helper(other, &obj)) {
3157 PyErr_Clear();
3158 return true;
3159 }
3160 return self->operator!=(*obj);
3161 }
3162 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3163 self->m_x = x;
3164 self->m_y = y;
3165 }
3166 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3167 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3168 PyObject* tup = PyTuple_New(2);
3169 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3170 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3171 //wxPyEndBlockThreads(blocked);
3172 return tup;
3173 }
3174 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3175 wxRect2D temp, *obj = &temp;
3176 if ( other == Py_None ) return false;
3177 if ( ! wxRect2D_helper(other, &obj) ) {
3178 PyErr_Clear();
3179 return false;
3180 }
3181 return self->operator==(*obj);
3182 }
3183 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3184 wxRect2D temp, *obj = &temp;
3185 if ( other == Py_None ) return true;
3186 if ( ! wxRect2D_helper(other, &obj)) {
3187 PyErr_Clear();
3188 return true;
3189 }
3190 return self->operator!=(*obj);
3191 }
3192 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3193 self->m_x = x;
3194 self->m_y = y;
3195 self->m_width = width;
3196 self->m_height = height;
3197 }
3198 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3199 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 PyObject* tup = PyTuple_New(4);
3201 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3202 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3203 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3204 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3205 //wxPyEndBlockThreads(blocked);
3206 return tup;
3207 }
3208
3209 #include "wx/wxPython/pyistream.h"
3210
3211 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3212 wxInputStream* wxis = wxPyCBInputStream::create(p);
3213 if (wxis)
3214 return new wxPyInputStream(wxis);
3215 else
3216 return NULL;
3217 }
3218
3219 SWIGINTERN swig_type_info*
3220 SWIG_pchar_descriptor()
3221 {
3222 static int init = 0;
3223 static swig_type_info* info = 0;
3224 if (!init) {
3225 info = SWIG_TypeQuery("_p_char");
3226 init = 1;
3227 }
3228 return info;
3229 }
3230
3231
3232 SWIGINTERNINLINE PyObject *
3233 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3234 {
3235 if (carray) {
3236 if (size > INT_MAX) {
3237 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3238 return pchar_descriptor ?
3239 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3240 } else {
3241 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3242 }
3243 } else {
3244 return SWIG_Py_Void();
3245 }
3246 }
3247
3248
3249 SWIGINTERNINLINE PyObject *
3250 SWIG_From_char (char c)
3251 {
3252 return SWIG_FromCharPtrAndSize(&c,1);
3253 }
3254
3255
3256 SWIGINTERNINLINE PyObject*
3257 SWIG_From_unsigned_SS_long (unsigned long value)
3258 {
3259 return (value > LONG_MAX) ?
3260 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3261 }
3262
3263
3264 SWIGINTERNINLINE PyObject *
3265 SWIG_From_size_t (size_t value)
3266 {
3267 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3268 }
3269
3270
3271 SWIGINTERN int
3272 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3273 {
3274 if (PyString_Check(obj)) {
3275 char *cstr; Py_ssize_t len;
3276 PyString_AsStringAndSize(obj, &cstr, &len);
3277 if (cptr) {
3278 if (alloc) {
3279 /*
3280 In python the user should not be able to modify the inner
3281 string representation. To warranty that, if you define
3282 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3283 buffer is always returned.
3284
3285 The default behavior is just to return the pointer value,
3286 so, be careful.
3287 */
3288 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3289 if (*alloc != SWIG_OLDOBJ)
3290 #else
3291 if (*alloc == SWIG_NEWOBJ)
3292 #endif
3293 {
3294 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3295 *alloc = SWIG_NEWOBJ;
3296 }
3297 else {
3298 *cptr = cstr;
3299 *alloc = SWIG_OLDOBJ;
3300 }
3301 } else {
3302 *cptr = PyString_AsString(obj);
3303 }
3304 }
3305 if (psize) *psize = len + 1;
3306 return SWIG_OK;
3307 } else {
3308 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3309 if (pchar_descriptor) {
3310 void* vptr = 0;
3311 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3312 if (cptr) *cptr = (char *) vptr;
3313 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3314 if (alloc) *alloc = SWIG_OLDOBJ;
3315 return SWIG_OK;
3316 }
3317 }
3318 }
3319 return SWIG_TypeError;
3320 }
3321
3322
3323 SWIGINTERN int
3324 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3325 {
3326 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3327 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3328 if (SWIG_IsOK(res)) {
3329 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3330 if (csize <= size) {
3331 if (val) {
3332 if (csize) memcpy(val, cptr, csize*sizeof(char));
3333 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3334 }
3335 if (alloc == SWIG_NEWOBJ) {
3336 delete[] cptr;
3337 res = SWIG_DelNewMask(res);
3338 }
3339 return res;
3340 }
3341 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3342 }
3343 return SWIG_TypeError;
3344 }
3345
3346
3347 SWIGINTERN int
3348 SWIG_AsVal_char (PyObject * obj, char *val)
3349 {
3350 int res = SWIG_AsCharArray(obj, val, 1);
3351 if (!SWIG_IsOK(res)) {
3352 long v;
3353 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3354 if (SWIG_IsOK(res)) {
3355 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3356 if (val) *val = static_cast< char >(v);
3357 } else {
3358 res = SWIG_OverflowError;
3359 }
3360 }
3361 }
3362 return res;
3363 }
3364
3365 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3366 // We use only strings for the streams, not unicode
3367 PyObject* str = PyObject_Str(obj);
3368 if (! str) {
3369 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3370 return;
3371 }
3372 self->Write(PyString_AS_STRING(str),
3373 PyString_GET_SIZE(str));
3374 Py_DECREF(str);
3375 }
3376
3377 #include "wx/wxPython/pyistream.h"
3378
3379
3380 class wxPyFileSystemHandler : public wxFileSystemHandler
3381 {
3382 public:
3383 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3384
3385 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3386 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3387 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3388 DEC_PYCALLBACK_STRING__pure(FindNext);
3389
3390 wxString GetProtocol(const wxString& location) {
3391 return wxFileSystemHandler::GetProtocol(location);
3392 }
3393
3394 wxString GetLeftLocation(const wxString& location) {
3395 return wxFileSystemHandler::GetLeftLocation(location);
3396 }
3397
3398 wxString GetAnchor(const wxString& location) {
3399 return wxFileSystemHandler::GetAnchor(location);
3400 }
3401
3402 wxString GetRightLocation(const wxString& location) {
3403 return wxFileSystemHandler::GetRightLocation(location);
3404 }
3405
3406 wxString GetMimeTypeFromExt(const wxString& location) {
3407 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3408 }
3409
3410 PYPRIVATE;
3411 };
3412
3413
3414 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3415 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3416 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3417 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_bool (PyObject *obj, bool *val)
3422 {
3423 if (obj == Py_True) {
3424 if (val) *val = true;
3425 return SWIG_OK;
3426 } else if (obj == Py_False) {
3427 if (val) *val = false;
3428 return SWIG_OK;
3429 } else {
3430 long v = 0;
3431 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3432 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3433 return res;
3434 }
3435 }
3436
3437 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3438 wxFileName fname = wxFileSystem::URLToFileName(url);
3439 return fname.GetFullPath();
3440 }
3441
3442 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3443 wxImage& image,
3444 long type) {
3445 wxMemoryFSHandler::AddFile(filename, image, type);
3446 }
3447
3448 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3449 const wxBitmap& bitmap,
3450 long type) {
3451 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3452 }
3453
3454 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3455 PyObject* data) {
3456 if (! PyString_Check(data)) {
3457 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3458 "Expected string object"));
3459 return;
3460 }
3461
3462 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3463 void* ptr = (void*)PyString_AsString(data);
3464 size_t size = PyString_Size(data);
3465 wxPyEndBlockThreads(blocked);
3466
3467 wxMemoryFSHandler::AddFile(filename, ptr, size);
3468 }
3469
3470
3471 #include "wx/wxPython/pyistream.h"
3472
3473
3474 SWIGINTERN int
3475 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3476 {
3477 long v = 0;
3478 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3479 return SWIG_TypeError;
3480 }
3481 else if (val)
3482 *val = (unsigned long)v;
3483 return SWIG_OK;
3484 }
3485
3486
3487 SWIGINTERN int
3488 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3489 {
3490 unsigned long v;
3491 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3492 if (SWIG_IsOK(res)) {
3493 if ((v > UCHAR_MAX)) {
3494 return SWIG_OverflowError;
3495 } else {
3496 if (val) *val = static_cast< unsigned char >(v);
3497 }
3498 }
3499 return res;
3500 }
3501
3502
3503 SWIGINTERNINLINE PyObject *
3504 SWIG_From_unsigned_SS_char (unsigned char value)
3505 {
3506 return SWIG_From_unsigned_SS_long (value);
3507 }
3508
3509 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3510 wxImageHistogramEntry e = (*self)[key];
3511 return e.value;
3512 }
3513 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3514 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3515 wxImageHistogramEntry e = (*self)[key];
3516 return e.value;
3517 }
3518 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3519 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3520 colour.Green(),
3521 colour.Blue());
3522 wxImageHistogramEntry e = (*self)[key];
3523 return e.value;
3524 }
3525
3526 // Pull the nested class out to the top level for SWIG's sake
3527 #define wxImage_RGBValue wxImage::RGBValue
3528 #define wxImage_HSVValue wxImage::HSVValue
3529
3530 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3531 if (width > 0 && height > 0)
3532 return new wxImage(width, height, clear);
3533 else
3534 return new wxImage;
3535 }
3536 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3537 return new wxImage(bitmap.ConvertToImage());
3538 }
3539 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3540 if (DATASIZE != width*height*3) {
3541 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3542 return NULL;
3543 }
3544
3545 // Copy the source data so the wxImage can clean it up later
3546 buffer copy = (buffer)malloc(DATASIZE);
3547 if (copy == NULL) {
3548 wxPyBLOCK_THREADS(PyErr_NoMemory());
3549 return NULL;
3550 }
3551 memcpy(copy, data, DATASIZE);
3552 return new wxImage(width, height, copy, false);
3553 }
3554 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3555 if (DATASIZE != width*height*3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return NULL;
3558 }
3559 if (ALPHASIZE != width*height) {
3560 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3561 return NULL;
3562 }
3563
3564 // Copy the source data so the wxImage can clean it up later
3565 buffer dcopy = (buffer)malloc(DATASIZE);
3566 if (dcopy == NULL) {
3567 wxPyBLOCK_THREADS(PyErr_NoMemory());
3568 return NULL;
3569 }
3570 memcpy(dcopy, data, DATASIZE);
3571
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return NULL;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578
3579 return new wxImage(width, height, dcopy, acopy, false);
3580 }
3581 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3582 wxSize size(self->GetWidth(), self->GetHeight());
3583 return size;
3584 }
3585 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3586 buffer data = self->GetData();
3587 int len = self->GetWidth() * self->GetHeight() * 3;
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3590 return rv;
3591 }
3592 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3593 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3595 return;
3596 }
3597 buffer copy = (buffer)malloc(DATASIZE);
3598 if (copy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(copy, data, DATASIZE);
3603 self->SetData(copy, false);
3604 // wxImage takes ownership of copy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3607 buffer data = self->GetData();
3608 int len = self->GetWidth() * self->GetHeight() * 3;
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3614 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3616 return;
3617 }
3618 self->SetData(data, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3621 buffer data = self->GetAlpha();
3622 if (! data) {
3623 RETURN_NONE();
3624 } else {
3625 int len = self->GetWidth() * self->GetHeight();
3626 PyObject* rv;
3627 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3628 return rv;
3629 }
3630 }
3631 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3632 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3633 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3634 return;
3635 }
3636 buffer acopy = (buffer)malloc(ALPHASIZE);
3637 if (acopy == NULL) {
3638 wxPyBLOCK_THREADS(PyErr_NoMemory());
3639 return;
3640 }
3641 memcpy(acopy, alpha, ALPHASIZE);
3642 self->SetAlpha(acopy, false);
3643 // wxImage takes ownership of acopy...
3644 }
3645 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3646 buffer data = self->GetAlpha();
3647 int len = self->GetWidth() * self->GetHeight();
3648 PyObject* rv;
3649 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3650 return rv;
3651 }
3652 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3653 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3654 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3655 return;
3656 }
3657 self->SetAlpha(alpha, true);
3658 }
3659 SWIGINTERN PyObject *wxImage_GetHandlers(){
3660 wxList& list = wxImage::GetHandlers();
3661 return wxPy_ConvertList(&list);
3662 }
3663 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3664 wxBitmap bitmap(*self, depth);
3665 return bitmap;
3666 }
3667 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3668 wxImage mono = self->ConvertToMono( red, green, blue );
3669 wxBitmap bitmap( mono, 1 );
3670 return bitmap;
3671 }
3672
3673 wxImage* _ImageFromBuffer(int width, int height,
3674 buffer data, int DATASIZE,
3675 buffer alpha=NULL, int ALPHASIZE=0)
3676 {
3677 if (DATASIZE != width*height*3) {
3678 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3679 return NULL;
3680 }
3681 if (alpha != NULL) {
3682 if (ALPHASIZE != width*height) {
3683 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3684 return NULL;
3685 }
3686 return new wxImage(width, height, data, alpha, true);
3687 }
3688 return new wxImage(width, height, data, true);
3689 }
3690
3691 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3692 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3693 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3695 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3699 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3700 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3701 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3702 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3703 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3704 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3705 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3706
3707 #include <wx/quantize.h>
3708
3709 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3710 return wxQuantize::Quantize(src, dest,
3711 //NULL, // palette
3712 desiredNoColours,
3713 NULL, // eightBitData
3714 flags);
3715 }
3716 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3717 if (PyCallable_Check(func)) {
3718 self->Connect(id, lastId, eventType,
3719 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3720 new wxPyCallback(func));
3721 }
3722 else if (func == Py_None) {
3723 self->Disconnect(id, lastId, eventType,
3724 (wxObjectEventFunction)
3725 &wxPyCallback::EventThunker);
3726 }
3727 else {
3728 wxPyBLOCK_THREADS(
3729 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3730 }
3731 }
3732 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3733 return self->Disconnect(id, lastId, eventType,
3734 (wxObjectEventFunction)
3735 &wxPyCallback::EventThunker);
3736 }
3737 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3738 if (_self && _self != Py_None) {
3739 self->SetClientObject(new wxPyOORClientData(_self, incref));
3740 }
3741 else {
3742 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3743 if (data) {
3744 self->SetClientObject(NULL); // This will delete it too
3745 }
3746 }
3747 }
3748
3749 #if ! wxUSE_HOTKEY
3750 #define wxEVT_HOTKEY -9999
3751 #endif
3752
3753 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3754 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3755 if (data) {
3756 Py_INCREF(data->m_obj);
3757 return data->m_obj;
3758 } else {
3759 Py_INCREF(Py_None);
3760 return Py_None;
3761 }
3762 }
3763 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3764 wxPyClientData* data = new wxPyClientData(clientData);
3765 self->SetClientObject(data);
3766 }
3767 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3768 #if wxUSE_UNICODE
3769 return self->GetUnicodeKey();
3770 #else
3771 return 0;
3772 #endif
3773 }
3774 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3775 #if wxUSE_UNICODE
3776 self->m_uniChar = uniChar;
3777 #endif
3778 }
3779
3780 SWIGINTERNINLINE PyObject *
3781 SWIG_From_unsigned_SS_int (unsigned int value)
3782 {
3783 return SWIG_From_unsigned_SS_long (value);
3784 }
3785
3786
3787 SWIGINTERN int
3788 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3789 {
3790 unsigned long v;
3791 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3792 if (SWIG_IsOK(res)) {
3793 if ((v > UINT_MAX)) {
3794 return SWIG_OverflowError;
3795 } else {
3796 if (val) *val = static_cast< unsigned int >(v);
3797 }
3798 }
3799 return res;
3800 }
3801
3802 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3803 self->m_size = size;
3804 }
3805 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3806 int count = self->GetNumberOfFiles();
3807 wxString* files = self->GetFiles();
3808 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3809 PyObject* list = PyList_New(count);
3810
3811 if (!list) {
3812 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3813 wxPyEndBlockThreads(blocked);
3814 return NULL;
3815 }
3816
3817 for (int i=0; i<count; i++) {
3818 PyList_SetItem(list, i, wx2PyString(files[i]));
3819 }
3820 wxPyEndBlockThreads(blocked);
3821 return list;
3822 }
3823
3824
3825 SWIGINTERN wxPyApp *new_wxPyApp(){
3826 wxPythonApp = new wxPyApp();
3827 return wxPythonApp;
3828 }
3829 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3830 return wxPyTestDisplayAvailable();
3831 }
3832
3833 void wxApp_CleanUp() {
3834 __wxPyCleanup();
3835 }
3836
3837
3838 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3839
3840
3841
3842
3843
3844 SWIGINTERNINLINE PyObject *
3845 SWIG_FromCharPtr(const char *cptr)
3846 {
3847 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3848 }
3849
3850
3851 #if 0 // #ifdef __WXMAC__
3852
3853 // A dummy class that raises an exception if used...
3854 class wxEventLoop
3855 {
3856 public:
3857 wxEventLoop() { wxPyRaiseNotImplemented(); }
3858 int Run() { return 0; }
3859 void Exit(int rc = 0) {}
3860 bool Pending() const { return false; }
3861 bool Dispatch() { return false; }
3862 bool IsRunning() const { return false; }
3863 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3864 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3865 };
3866
3867 #else
3868
3869 #include <wx/evtloop.h>
3870
3871 #endif
3872
3873
3874
3875 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3876 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3877 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3878 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3879 wxWindowList& list = self->GetChildren();
3880 return wxPy_ConvertList(&list);
3881 }
3882 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3883 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3884 #if wxUSE_HOTKEY
3885 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3886 #else
3887 return false;
3888 #endif
3889 }
3890 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3891
3892
3893
3894 return false;
3895
3896 }
3897 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3898 return wxPyGetWinHandle(self);
3899 }
3900 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3901 self->AssociateHandle((WXWidget)handle);
3902 }
3903
3904 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3905 return wxWindow::FindWindowById(id, parent);
3906 }
3907
3908 wxWindow* wxFindWindowByName( const wxString& name,
3909 const wxWindow *parent = NULL ) {
3910 return wxWindow::FindWindowByName(name, parent);
3911 }
3912
3913 wxWindow* wxFindWindowByLabel( const wxString& label,
3914 const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowByLabel(label, parent);
3916 }
3917
3918
3919 #ifdef __WXMSW__
3920 #include <wx/msw/private.h> // to get wxGetWindowId
3921 #endif
3922
3923
3924 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3925 #ifdef __WXMSW__
3926 WXHWND hWnd = (WXHWND)_hWnd;
3927 long id = wxGetWindowId(hWnd);
3928 wxWindow* win = new wxWindow;
3929 if (parent)
3930 parent->AddChild(win);
3931 win->SetEventHandler(win);
3932 win->SetHWND(hWnd);
3933 win->SetId(id);
3934 win->SubclassWin(hWnd);
3935 win->AdoptAttributesFromHWND();
3936 win->SetupColours();
3937 return win;
3938 #else
3939 wxPyRaiseNotImplemented();
3940 return NULL;
3941 #endif
3942 }
3943
3944
3945 PyObject* GetTopLevelWindows() {
3946 return wxPy_ConvertList(&wxTopLevelWindows);
3947 }
3948
3949
3950 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3951 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3952 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3953
3954 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3955
3956
3957 SWIGINTERNINLINE int
3958 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3959 {
3960 unsigned long v;
3961 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3962 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3963 return res;
3964 }
3965
3966 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3967 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3968 wxMenuItemList& list = self->GetMenuItems();
3969 return wxPy_ConvertList(&list);
3970 }
3971 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3972 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3973 static const wxString wxPyControlNameStr(wxControlNameStr);
3974 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3975 if (clientData) {
3976 wxPyClientData* data = new wxPyClientData(clientData);
3977 return self->Append(item, data);
3978 } else
3979 return self->Append(item);
3980 }
3981 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3982 if (clientData) {
3983 wxPyClientData* data = new wxPyClientData(clientData);
3984 return self->Insert(item, pos, data);
3985 } else
3986 return self->Insert(item, pos);
3987 }
3988 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3989 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3990 if (data) {
3991 Py_INCREF(data->m_obj);
3992 return data->m_obj;
3993 } else {
3994 Py_INCREF(Py_None);
3995 return Py_None;
3996 }
3997 }
3998 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3999 wxPyClientData* data = new wxPyClientData(clientData);
4000 self->SetClientObject(n, data);
4001 }
4002
4003
4004 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4005 wxPyUserData* data = NULL;
4006 if ( userData ) {
4007 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4008 data = new wxPyUserData(userData);
4009 wxPyEndBlockThreads(blocked);
4010 }
4011 return new wxSizerItem(window, proportion, flag, border, data);
4012 }
4013 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4014 wxPyUserData* data = NULL;
4015 if ( userData ) {
4016 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4017 data = new wxPyUserData(userData);
4018 wxPyEndBlockThreads(blocked);
4019 }
4020 return new wxSizerItem(width, height, proportion, flag, border, data);
4021 }
4022 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4023 wxPyUserData* data = NULL;
4024 if ( userData ) {
4025 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4026 data = new wxPyUserData(userData);
4027 wxPyEndBlockThreads(blocked);
4028 }
4029 return new wxSizerItem(sizer, proportion, flag, border, data);
4030 }
4031
4032 SWIGINTERNINLINE PyObject *
4033 SWIG_From_float (float value)
4034 {
4035 return SWIG_From_double (value);
4036 }
4037
4038 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4039 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4040 if (data) {
4041 Py_INCREF(data->m_obj);
4042 return data->m_obj;
4043 } else {
4044 Py_INCREF(Py_None);
4045 return Py_None;
4046 }
4047 }
4048 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4049 wxPyUserData* data = NULL;
4050 if ( userData ) {
4051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4052 data = new wxPyUserData(userData);
4053 wxPyEndBlockThreads(blocked);
4054 }
4055 self->SetUserData(data);
4056 }
4057
4058 // Figure out the type of the sizer item
4059
4060 struct wxPySizerItemInfo {
4061 wxPySizerItemInfo()
4062 : window(NULL), sizer(NULL), gotSize(false),
4063 size(wxDefaultSize), gotPos(false), pos(-1)
4064 {}
4065
4066 wxWindow* window;
4067 wxSizer* sizer;
4068 bool gotSize;
4069 wxSize size;
4070 bool gotPos;
4071 int pos;
4072 };
4073
4074 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4075
4076 wxPySizerItemInfo info;
4077 wxSize size;
4078 wxSize* sizePtr = &size;
4079
4080 // Find out what the type of the item is
4081 // try wxWindow
4082 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4083 PyErr_Clear();
4084 info.window = NULL;
4085
4086 // try wxSizer
4087 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4088 PyErr_Clear();
4089 info.sizer = NULL;
4090
4091 // try wxSize or (w,h)
4092 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4093 info.size = *sizePtr;
4094 info.gotSize = true;
4095 }
4096
4097 // or a single int
4098 if (checkIdx && PyInt_Check(item)) {
4099 info.pos = PyInt_AsLong(item);
4100 info.gotPos = true;
4101 }
4102 }
4103 }
4104
4105 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4106 // no expected type, figure out what kind of error message to generate
4107 if ( !checkSize && !checkIdx )
4108 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4109 else if ( checkSize && !checkIdx )
4110 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4111 else if ( !checkSize && checkIdx)
4112 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4113 else
4114 // can this one happen?
4115 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4116 }
4117
4118 return info;
4119 }
4120
4121 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4122 if (!self->GetClientObject())
4123 self->SetClientObject(new wxPyOORClientData(_self));
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Add method if a valid item type was found
4137 if ( info.window )
4138 return self->Add(info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Add(info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4148
4149 wxPyUserData* data = NULL;
4150 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4151 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4152 if ( userData && (info.window || info.sizer || info.gotSize) )
4153 data = new wxPyUserData(userData);
4154 if ( info.sizer )
4155 PyObject_SetAttrString(item,"thisown",Py_False);
4156 wxPyEndBlockThreads(blocked);
4157
4158 // Now call the real Insert method if a valid item type was found
4159 if ( info.window )
4160 return self->Insert(before, info.window, proportion, flag, border, data);
4161 else if ( info.sizer )
4162 return self->Insert(before, info.sizer, proportion, flag, border, data);
4163 else if (info.gotSize)
4164 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4165 proportion, flag, border, data);
4166 else
4167 return NULL;
4168 }
4169 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4170
4171 wxPyUserData* data = NULL;
4172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4173 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4174 if ( userData && (info.window || info.sizer || info.gotSize) )
4175 data = new wxPyUserData(userData);
4176 if ( info.sizer )
4177 PyObject_SetAttrString(item,"thisown",Py_False);
4178 wxPyEndBlockThreads(blocked);
4179
4180 // Now call the real Prepend method if a valid item type was found
4181 if ( info.window )
4182 return self->Prepend(info.window, proportion, flag, border, data);
4183 else if ( info.sizer )
4184 return self->Prepend(info.sizer, proportion, flag, border, data);
4185 else if (info.gotSize)
4186 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4187 proportion, flag, border, data);
4188 else
4189 return NULL;
4190 }
4191 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4194 wxPyEndBlockThreads(blocked);
4195 if ( info.window )
4196 return self->Remove(info.window);
4197 else if ( info.sizer )
4198 return self->Remove(info.sizer);
4199 else if ( info.gotPos )
4200 return self->Remove(info.pos);
4201 else
4202 return false;
4203 }
4204 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4205 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4206 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4207 wxPyEndBlockThreads(blocked);
4208 if ( info.window )
4209 return self->Detach(info.window);
4210 else if ( info.sizer )
4211 return self->Detach(info.sizer);
4212 else if ( info.gotPos )
4213 return self->Detach(info.pos);
4214 else
4215 return false;
4216 }
4217 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4218 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4219 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4220 wxPyEndBlockThreads(blocked);
4221 if ( info.window )
4222 return self->GetItem(info.window);
4223 else if ( info.sizer )
4224 return self->GetItem(info.sizer);
4225 else if ( info.gotPos )
4226 return self->GetItem(info.pos);
4227 else
4228 return NULL;
4229 }
4230 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4231 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4232 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4233 wxPyEndBlockThreads(blocked);
4234 if ( info.window )
4235 self->SetItemMinSize(info.window, size);
4236 else if ( info.sizer )
4237 self->SetItemMinSize(info.sizer, size);
4238 else if ( info.gotPos )
4239 self->SetItemMinSize(info.pos, size);
4240 }
4241 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4242 wxSizerItemList& list = self->GetChildren();
4243 return wxPy_ConvertList(&list);
4244 }
4245 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4248 wxPyEndBlockThreads(blocked);
4249 if ( info.window )
4250 return self->Show(info.window, show, recursive);
4251 else if ( info.sizer )
4252 return self->Show(info.sizer, show, recursive);
4253 else if ( info.gotPos )
4254 return self->Show(info.pos, show);
4255 else
4256 return false;
4257 }
4258 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4259 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4260 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4261 wxPyEndBlockThreads(blocked);
4262 if ( info.window )
4263 return self->IsShown(info.window);
4264 else if ( info.sizer )
4265 return self->IsShown(info.sizer);
4266 else if ( info.gotPos )
4267 return self->IsShown(info.pos);
4268 else
4269 return false;
4270 }
4271
4272 // See pyclasses.h
4273 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4274 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4275 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4276
4277
4278
4279
4280 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4281 {
4282 if (source == Py_None) {
4283 **obj = wxGBPosition(-1,-1);
4284 return true;
4285 }
4286 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4287 }
4288
4289 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4290 {
4291 if (source == Py_None) {
4292 **obj = wxGBSpan(-1,-1);
4293 return true;
4294 }
4295 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4296 }
4297
4298
4299 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4300 wxGBPosition temp, *obj = &temp;
4301 if ( other == Py_None ) return false;
4302 if ( ! wxGBPosition_helper(other, &obj) ) {
4303 PyErr_Clear();
4304 return false;
4305 }
4306 return self->operator==(*obj);
4307 }
4308 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4309 wxGBPosition temp, *obj = &temp;
4310 if ( other == Py_None ) return true;
4311 if ( ! wxGBPosition_helper(other, &obj)) {
4312 PyErr_Clear();
4313 return true;
4314 }
4315 return self->operator!=(*obj);
4316 }
4317 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4318 self->SetRow(row);
4319 self->SetCol(col);
4320 }
4321 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 PyObject* tup = PyTuple_New(2);
4324 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4325 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4326 wxPyEndBlockThreads(blocked);
4327 return tup;
4328 }
4329 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4330 wxGBSpan temp, *obj = &temp;
4331 if ( other == Py_None ) return false;
4332 if ( ! wxGBSpan_helper(other, &obj) ) {
4333 PyErr_Clear();
4334 return false;
4335 }
4336 return self->operator==(*obj);
4337 }
4338 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4339 wxGBSpan temp, *obj = &temp;
4340 if ( other == Py_None ) return true;
4341 if ( ! wxGBSpan_helper(other, &obj)) {
4342 PyErr_Clear();
4343 return true;
4344 }
4345 return self->operator!=(*obj);
4346 }
4347 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4348 self->SetRowspan(rowspan);
4349 self->SetColspan(colspan);
4350 }
4351 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4353 PyObject* tup = PyTuple_New(2);
4354 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4355 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4356 wxPyEndBlockThreads(blocked);
4357 return tup;
4358 }
4359 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4360 wxPyUserData* data = NULL;
4361 if ( userData ) {
4362 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4363 data = new wxPyUserData(userData);
4364 wxPyEndBlockThreads(blocked);
4365 }
4366 return new wxGBSizerItem(window, pos, span, flag, border, data);
4367 }
4368 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4369 wxPyUserData* data = NULL;
4370 if ( userData ) {
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 data = new wxPyUserData(userData);
4373 wxPyEndBlockThreads(blocked);
4374 }
4375 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4376 }
4377 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4378 wxPyUserData* data = NULL;
4379 if ( userData ) {
4380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4381 data = new wxPyUserData(userData);
4382 wxPyEndBlockThreads(blocked);
4383 }
4384 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4385 }
4386 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4387 int row, col;
4388 self->GetEndPos(row, col);
4389 return wxGBPosition(row, col);
4390 }
4391 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4392
4393 wxPyUserData* data = NULL;
4394 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4395 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4396 if ( userData && (info.window || info.sizer || info.gotSize) )
4397 data = new wxPyUserData(userData);
4398 if ( info.sizer )
4399 PyObject_SetAttrString(item,"thisown",Py_False);
4400 wxPyEndBlockThreads(blocked);
4401
4402 // Now call the real Add method if a valid item type was found
4403 if ( info.window )
4404 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4405 else if ( info.sizer )
4406 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4407 else if (info.gotSize)
4408 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4409 pos, span, flag, border, data);
4410 return NULL;
4411 }
4412
4413
4414 #ifdef __cplusplus
4415 extern "C" {
4416 #endif
4417 SWIGINTERN int EmptyString_set(PyObject *) {
4418 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4419 return 1;
4420 }
4421
4422
4423 SWIGINTERN PyObject *EmptyString_get(void) {
4424 PyObject *pyobj = 0;
4425
4426 {
4427 #if wxUSE_UNICODE
4428 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4429 #else
4430 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4431 #endif
4432 }
4433 return pyobj;
4434 }
4435
4436
4437 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4438 PyObject *resultobj = 0;
4439 wxObject *arg1 = (wxObject *) 0 ;
4440 wxString result;
4441 void *argp1 = 0 ;
4442 int res1 = 0 ;
4443 PyObject *swig_obj[1] ;
4444
4445 if (!args) SWIG_fail;
4446 swig_obj[0] = args;
4447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4448 if (!SWIG_IsOK(res1)) {
4449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4450 }
4451 arg1 = reinterpret_cast< wxObject * >(argp1);
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = wxObject_GetClassName(arg1);
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 {
4459 #if wxUSE_UNICODE
4460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4461 #else
4462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4463 #endif
4464 }
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4472 PyObject *resultobj = 0;
4473 wxObject *arg1 = (wxObject *) 0 ;
4474 void *argp1 = 0 ;
4475 int res1 = 0 ;
4476 PyObject *swig_obj[1] ;
4477
4478 if (!args) SWIG_fail;
4479 swig_obj[0] = args;
4480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4481 if (!SWIG_IsOK(res1)) {
4482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4483 }
4484 arg1 = reinterpret_cast< wxObject * >(argp1);
4485 {
4486 PyThreadState* __tstate = wxPyBeginAllowThreads();
4487 wxObject_Destroy(arg1);
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 resultobj = SWIG_Py_Void();
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4499 PyObject *obj;
4500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4501 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4502 return SWIG_Py_Void();
4503 }
4504
4505 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4506 PyObject *resultobj = 0;
4507 wxSize *arg1 = (wxSize *) 0 ;
4508 int arg2 ;
4509 void *argp1 = 0 ;
4510 int res1 = 0 ;
4511 int val2 ;
4512 int ecode2 = 0 ;
4513 PyObject *swig_obj[2] ;
4514
4515 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4517 if (!SWIG_IsOK(res1)) {
4518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4519 }
4520 arg1 = reinterpret_cast< wxSize * >(argp1);
4521 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4522 if (!SWIG_IsOK(ecode2)) {
4523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4524 }
4525 arg2 = static_cast< int >(val2);
4526 if (arg1) (arg1)->x = arg2;
4527
4528 resultobj = SWIG_Py_Void();
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536 PyObject *resultobj = 0;
4537 wxSize *arg1 = (wxSize *) 0 ;
4538 int result;
4539 void *argp1 = 0 ;
4540 int res1 = 0 ;
4541 PyObject *swig_obj[1] ;
4542
4543 if (!args) SWIG_fail;
4544 swig_obj[0] = args;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 result = (int) ((arg1)->x);
4551 resultobj = SWIG_From_int(static_cast< int >(result));
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4559 PyObject *resultobj = 0;
4560 wxSize *arg1 = (wxSize *) 0 ;
4561 int arg2 ;
4562 void *argp1 = 0 ;
4563 int res1 = 0 ;
4564 int val2 ;
4565 int ecode2 = 0 ;
4566 PyObject *swig_obj[2] ;
4567
4568 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4570 if (!SWIG_IsOK(res1)) {
4571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4572 }
4573 arg1 = reinterpret_cast< wxSize * >(argp1);
4574 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4575 if (!SWIG_IsOK(ecode2)) {
4576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4577 }
4578 arg2 = static_cast< int >(val2);
4579 if (arg1) (arg1)->y = arg2;
4580
4581 resultobj = SWIG_Py_Void();
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 PyObject *resultobj = 0;
4590 wxSize *arg1 = (wxSize *) 0 ;
4591 int result;
4592 void *argp1 = 0 ;
4593 int res1 = 0 ;
4594 PyObject *swig_obj[1] ;
4595
4596 if (!args) SWIG_fail;
4597 swig_obj[0] = args;
4598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4599 if (!SWIG_IsOK(res1)) {
4600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4601 }
4602 arg1 = reinterpret_cast< wxSize * >(argp1);
4603 result = (int) ((arg1)->y);
4604 resultobj = SWIG_From_int(static_cast< int >(result));
4605 return resultobj;
4606 fail:
4607 return NULL;
4608 }
4609
4610
4611 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4612 PyObject *resultobj = 0;
4613 int arg1 = (int) 0 ;
4614 int arg2 = (int) 0 ;
4615 wxSize *result = 0 ;
4616 int val1 ;
4617 int ecode1 = 0 ;
4618 int val2 ;
4619 int ecode2 = 0 ;
4620 PyObject * obj0 = 0 ;
4621 PyObject * obj1 = 0 ;
4622 char * kwnames[] = {
4623 (char *) "w",(char *) "h", NULL
4624 };
4625
4626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4627 if (obj0) {
4628 ecode1 = SWIG_AsVal_int(obj0, &val1);
4629 if (!SWIG_IsOK(ecode1)) {
4630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4631 }
4632 arg1 = static_cast< int >(val1);
4633 }
4634 if (obj1) {
4635 ecode2 = SWIG_AsVal_int(obj1, &val2);
4636 if (!SWIG_IsOK(ecode2)) {
4637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4638 }
4639 arg2 = static_cast< int >(val2);
4640 }
4641 {
4642 result = (wxSize *)new wxSize(arg1,arg2);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 void *argp1 = 0 ;
4656 int res1 = 0 ;
4657 PyObject *swig_obj[1] ;
4658
4659 if (!args) SWIG_fail;
4660 swig_obj[0] = args;
4661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4664 }
4665 arg1 = reinterpret_cast< wxSize * >(argp1);
4666 {
4667 delete arg1;
4668
4669 if (PyErr_Occurred()) SWIG_fail;
4670 }
4671 resultobj = SWIG_Py_Void();
4672 return resultobj;
4673 fail:
4674 return NULL;
4675 }
4676
4677
4678 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4679 PyObject *resultobj = 0;
4680 wxSize *arg1 = (wxSize *) 0 ;
4681 PyObject *arg2 = (PyObject *) 0 ;
4682 bool result;
4683 void *argp1 = 0 ;
4684 int res1 = 0 ;
4685 PyObject * obj0 = 0 ;
4686 PyObject * obj1 = 0 ;
4687 char * kwnames[] = {
4688 (char *) "self",(char *) "other", NULL
4689 };
4690
4691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4693 if (!SWIG_IsOK(res1)) {
4694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4695 }
4696 arg1 = reinterpret_cast< wxSize * >(argp1);
4697 arg2 = obj1;
4698 {
4699 result = (bool)wxSize___eq__(arg1,arg2);
4700 if (PyErr_Occurred()) SWIG_fail;
4701 }
4702 {
4703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4704 }
4705 return resultobj;
4706 fail:
4707 return NULL;
4708 }
4709
4710
4711 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4712 PyObject *resultobj = 0;
4713 wxSize *arg1 = (wxSize *) 0 ;
4714 PyObject *arg2 = (PyObject *) 0 ;
4715 bool result;
4716 void *argp1 = 0 ;
4717 int res1 = 0 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "self",(char *) "other", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 arg2 = obj1;
4731 {
4732 result = (bool)wxSize___ne__(arg1,arg2);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 {
4736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4737 }
4738 return resultobj;
4739 fail:
4740 return NULL;
4741 }
4742
4743
4744 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4745 PyObject *resultobj = 0;
4746 wxSize *arg1 = (wxSize *) 0 ;
4747 wxSize *arg2 = 0 ;
4748 wxSize result;
4749 void *argp1 = 0 ;
4750 int res1 = 0 ;
4751 wxSize temp2 ;
4752 PyObject * obj0 = 0 ;
4753 PyObject * obj1 = 0 ;
4754 char * kwnames[] = {
4755 (char *) "self",(char *) "sz", NULL
4756 };
4757
4758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4760 if (!SWIG_IsOK(res1)) {
4761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4762 }
4763 arg1 = reinterpret_cast< wxSize * >(argp1);
4764 {
4765 arg2 = &temp2;
4766 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4767 }
4768 {
4769 result = (arg1)->operator +((wxSize const &)*arg2);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4773 return resultobj;
4774 fail:
4775 return NULL;
4776 }
4777
4778
4779 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj = 0;
4781 wxSize *arg1 = (wxSize *) 0 ;
4782 wxSize *arg2 = 0 ;
4783 wxSize result;
4784 void *argp1 = 0 ;
4785 int res1 = 0 ;
4786 wxSize temp2 ;
4787 PyObject * obj0 = 0 ;
4788 PyObject * obj1 = 0 ;
4789 char * kwnames[] = {
4790 (char *) "self",(char *) "sz", NULL
4791 };
4792
4793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4795 if (!SWIG_IsOK(res1)) {
4796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4797 }
4798 arg1 = reinterpret_cast< wxSize * >(argp1);
4799 {
4800 arg2 = &temp2;
4801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4802 }
4803 {
4804 result = (arg1)->operator -((wxSize const &)*arg2);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj = 0;
4816 wxSize *arg1 = (wxSize *) 0 ;
4817 wxSize *arg2 = 0 ;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 wxSize temp2 ;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 char * kwnames[] = {
4824 (char *) "self",(char *) "sz", NULL
4825 };
4826
4827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4831 }
4832 arg1 = reinterpret_cast< wxSize * >(argp1);
4833 {
4834 arg2 = &temp2;
4835 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4836 }
4837 {
4838 (arg1)->IncTo((wxSize const &)*arg2);
4839 if (PyErr_Occurred()) SWIG_fail;
4840 }
4841 resultobj = SWIG_Py_Void();
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 wxSize *arg1 = (wxSize *) 0 ;
4851 wxSize *arg2 = 0 ;
4852 void *argp1 = 0 ;
4853 int res1 = 0 ;
4854 wxSize temp2 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char * kwnames[] = {
4858 (char *) "self",(char *) "sz", NULL
4859 };
4860
4861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4863 if (!SWIG_IsOK(res1)) {
4864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4865 }
4866 arg1 = reinterpret_cast< wxSize * >(argp1);
4867 {
4868 arg2 = &temp2;
4869 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4870 }
4871 {
4872 (arg1)->DecTo((wxSize const &)*arg2);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 resultobj = SWIG_Py_Void();
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 wxSize *arg1 = (wxSize *) 0 ;
4885 int arg2 ;
4886 int arg3 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 int val2 ;
4890 int ecode2 = 0 ;
4891 int val3 ;
4892 int ecode3 = 0 ;
4893 PyObject * obj0 = 0 ;
4894 PyObject * obj1 = 0 ;
4895 PyObject * obj2 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "self",(char *) "dx",(char *) "dy", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4902 if (!SWIG_IsOK(res1)) {
4903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4904 }
4905 arg1 = reinterpret_cast< wxSize * >(argp1);
4906 ecode2 = SWIG_AsVal_int(obj1, &val2);
4907 if (!SWIG_IsOK(ecode2)) {
4908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4909 }
4910 arg2 = static_cast< int >(val2);
4911 ecode3 = SWIG_AsVal_int(obj2, &val3);
4912 if (!SWIG_IsOK(ecode3)) {
4913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4914 }
4915 arg3 = static_cast< int >(val3);
4916 {
4917 (arg1)->IncBy(arg2,arg3);
4918 if (PyErr_Occurred()) SWIG_fail;
4919 }
4920 resultobj = SWIG_Py_Void();
4921 return resultobj;
4922 fail:
4923 return NULL;
4924 }
4925
4926
4927 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4928 PyObject *resultobj = 0;
4929 wxSize *arg1 = (wxSize *) 0 ;
4930 int arg2 ;
4931 int arg3 ;
4932 void *argp1 = 0 ;
4933 int res1 = 0 ;
4934 int val2 ;
4935 int ecode2 = 0 ;
4936 int val3 ;
4937 int ecode3 = 0 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 PyObject * obj2 = 0 ;
4941 char * kwnames[] = {
4942 (char *) "self",(char *) "dx",(char *) "dy", NULL
4943 };
4944
4945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4947 if (!SWIG_IsOK(res1)) {
4948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4949 }
4950 arg1 = reinterpret_cast< wxSize * >(argp1);
4951 ecode2 = SWIG_AsVal_int(obj1, &val2);
4952 if (!SWIG_IsOK(ecode2)) {
4953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4954 }
4955 arg2 = static_cast< int >(val2);
4956 ecode3 = SWIG_AsVal_int(obj2, &val3);
4957 if (!SWIG_IsOK(ecode3)) {
4958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4959 }
4960 arg3 = static_cast< int >(val3);
4961 {
4962 (arg1)->DecBy(arg2,arg3);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 resultobj = SWIG_Py_Void();
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4973 PyObject *resultobj = 0;
4974 wxSize *arg1 = (wxSize *) 0 ;
4975 float arg2 ;
4976 float arg3 ;
4977 void *argp1 = 0 ;
4978 int res1 = 0 ;
4979 float val2 ;
4980 int ecode2 = 0 ;
4981 float val3 ;
4982 int ecode3 = 0 ;
4983 PyObject * obj0 = 0 ;
4984 PyObject * obj1 = 0 ;
4985 PyObject * obj2 = 0 ;
4986 char * kwnames[] = {
4987 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4988 };
4989
4990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4992 if (!SWIG_IsOK(res1)) {
4993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4994 }
4995 arg1 = reinterpret_cast< wxSize * >(argp1);
4996 ecode2 = SWIG_AsVal_float(obj1, &val2);
4997 if (!SWIG_IsOK(ecode2)) {
4998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4999 }
5000 arg2 = static_cast< float >(val2);
5001 ecode3 = SWIG_AsVal_float(obj2, &val3);
5002 if (!SWIG_IsOK(ecode3)) {
5003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5004 }
5005 arg3 = static_cast< float >(val3);
5006 {
5007 (arg1)->Scale(arg2,arg3);
5008 if (PyErr_Occurred()) SWIG_fail;
5009 }
5010 resultobj = SWIG_Py_Void();
5011 return resultobj;
5012 fail:
5013 return NULL;
5014 }
5015
5016
5017 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5018 PyObject *resultobj = 0;
5019 wxSize *arg1 = (wxSize *) 0 ;
5020 int arg2 ;
5021 int arg3 ;
5022 void *argp1 = 0 ;
5023 int res1 = 0 ;
5024 int val2 ;
5025 int ecode2 = 0 ;
5026 int val3 ;
5027 int ecode3 = 0 ;
5028 PyObject * obj0 = 0 ;
5029 PyObject * obj1 = 0 ;
5030 PyObject * obj2 = 0 ;
5031 char * kwnames[] = {
5032 (char *) "self",(char *) "w",(char *) "h", NULL
5033 };
5034
5035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5037 if (!SWIG_IsOK(res1)) {
5038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5039 }
5040 arg1 = reinterpret_cast< wxSize * >(argp1);
5041 ecode2 = SWIG_AsVal_int(obj1, &val2);
5042 if (!SWIG_IsOK(ecode2)) {
5043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5044 }
5045 arg2 = static_cast< int >(val2);
5046 ecode3 = SWIG_AsVal_int(obj2, &val3);
5047 if (!SWIG_IsOK(ecode3)) {
5048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5049 }
5050 arg3 = static_cast< int >(val3);
5051 {
5052 (arg1)->Set(arg2,arg3);
5053 if (PyErr_Occurred()) SWIG_fail;
5054 }
5055 resultobj = SWIG_Py_Void();
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5063 PyObject *resultobj = 0;
5064 wxSize *arg1 = (wxSize *) 0 ;
5065 int arg2 ;
5066 void *argp1 = 0 ;
5067 int res1 = 0 ;
5068 int val2 ;
5069 int ecode2 = 0 ;
5070 PyObject * obj0 = 0 ;
5071 PyObject * obj1 = 0 ;
5072 char * kwnames[] = {
5073 (char *) "self",(char *) "w", NULL
5074 };
5075
5076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5078 if (!SWIG_IsOK(res1)) {
5079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5080 }
5081 arg1 = reinterpret_cast< wxSize * >(argp1);
5082 ecode2 = SWIG_AsVal_int(obj1, &val2);
5083 if (!SWIG_IsOK(ecode2)) {
5084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5085 }
5086 arg2 = static_cast< int >(val2);
5087 {
5088 (arg1)->SetWidth(arg2);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 resultobj = SWIG_Py_Void();
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5099 PyObject *resultobj = 0;
5100 wxSize *arg1 = (wxSize *) 0 ;
5101 int arg2 ;
5102 void *argp1 = 0 ;
5103 int res1 = 0 ;
5104 int val2 ;
5105 int ecode2 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "self",(char *) "h", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) 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_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5116 }
5117 arg1 = reinterpret_cast< wxSize * >(argp1);
5118 ecode2 = SWIG_AsVal_int(obj1, &val2);
5119 if (!SWIG_IsOK(ecode2)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5121 }
5122 arg2 = static_cast< int >(val2);
5123 {
5124 (arg1)->SetHeight(arg2);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 resultobj = SWIG_Py_Void();
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5135 PyObject *resultobj = 0;
5136 wxSize *arg1 = (wxSize *) 0 ;
5137 int result;
5138 void *argp1 = 0 ;
5139 int res1 = 0 ;
5140 PyObject *swig_obj[1] ;
5141
5142 if (!args) SWIG_fail;
5143 swig_obj[0] = args;
5144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5145 if (!SWIG_IsOK(res1)) {
5146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5147 }
5148 arg1 = reinterpret_cast< wxSize * >(argp1);
5149 {
5150 result = (int)((wxSize const *)arg1)->GetWidth();
5151 if (PyErr_Occurred()) SWIG_fail;
5152 }
5153 resultobj = SWIG_From_int(static_cast< int >(result));
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxSize *arg1 = (wxSize *) 0 ;
5163 int result;
5164 void *argp1 = 0 ;
5165 int res1 = 0 ;
5166 PyObject *swig_obj[1] ;
5167
5168 if (!args) SWIG_fail;
5169 swig_obj[0] = args;
5170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5171 if (!SWIG_IsOK(res1)) {
5172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5173 }
5174 arg1 = reinterpret_cast< wxSize * >(argp1);
5175 {
5176 result = (int)((wxSize const *)arg1)->GetHeight();
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 resultobj = SWIG_From_int(static_cast< int >(result));
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5187 PyObject *resultobj = 0;
5188 wxSize *arg1 = (wxSize *) 0 ;
5189 bool result;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 PyObject *swig_obj[1] ;
5193
5194 if (!args) SWIG_fail;
5195 swig_obj[0] = args;
5196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5199 }
5200 arg1 = reinterpret_cast< wxSize * >(argp1);
5201 {
5202 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5203 if (PyErr_Occurred()) SWIG_fail;
5204 }
5205 {
5206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5207 }
5208 return resultobj;
5209 fail:
5210 return NULL;
5211 }
5212
5213
5214 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5215 PyObject *resultobj = 0;
5216 wxSize *arg1 = (wxSize *) 0 ;
5217 wxSize *arg2 = 0 ;
5218 void *argp1 = 0 ;
5219 int res1 = 0 ;
5220 wxSize temp2 ;
5221 PyObject * obj0 = 0 ;
5222 PyObject * obj1 = 0 ;
5223 char * kwnames[] = {
5224 (char *) "self",(char *) "size", NULL
5225 };
5226
5227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5229 if (!SWIG_IsOK(res1)) {
5230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5231 }
5232 arg1 = reinterpret_cast< wxSize * >(argp1);
5233 {
5234 arg2 = &temp2;
5235 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5236 }
5237 {
5238 (arg1)->SetDefaults((wxSize const &)*arg2);
5239 if (PyErr_Occurred()) SWIG_fail;
5240 }
5241 resultobj = SWIG_Py_Void();
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5249 PyObject *resultobj = 0;
5250 wxSize *arg1 = (wxSize *) 0 ;
5251 PyObject *result = 0 ;
5252 void *argp1 = 0 ;
5253 int res1 = 0 ;
5254 PyObject *swig_obj[1] ;
5255
5256 if (!args) SWIG_fail;
5257 swig_obj[0] = args;
5258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5259 if (!SWIG_IsOK(res1)) {
5260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5261 }
5262 arg1 = reinterpret_cast< wxSize * >(argp1);
5263 {
5264 result = (PyObject *)wxSize_Get(arg1);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 resultobj = result;
5268 return resultobj;
5269 fail:
5270 return NULL;
5271 }
5272
5273
5274 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5275 PyObject *obj;
5276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5277 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5278 return SWIG_Py_Void();
5279 }
5280
5281 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 return SWIG_Python_InitShadowInstance(args);
5283 }
5284
5285 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5286 PyObject *resultobj = 0;
5287 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5288 double arg2 ;
5289 void *argp1 = 0 ;
5290 int res1 = 0 ;
5291 double val2 ;
5292 int ecode2 = 0 ;
5293 PyObject *swig_obj[2] ;
5294
5295 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5297 if (!SWIG_IsOK(res1)) {
5298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5299 }
5300 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5301 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5302 if (!SWIG_IsOK(ecode2)) {
5303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5304 }
5305 arg2 = static_cast< double >(val2);
5306 if (arg1) (arg1)->x = arg2;
5307
5308 resultobj = SWIG_Py_Void();
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5316 PyObject *resultobj = 0;
5317 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5318 double result;
5319 void *argp1 = 0 ;
5320 int res1 = 0 ;
5321 PyObject *swig_obj[1] ;
5322
5323 if (!args) SWIG_fail;
5324 swig_obj[0] = args;
5325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5326 if (!SWIG_IsOK(res1)) {
5327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5328 }
5329 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5330 result = (double) ((arg1)->x);
5331 resultobj = SWIG_From_double(static_cast< double >(result));
5332 return resultobj;
5333 fail:
5334 return NULL;
5335 }
5336
5337
5338 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5339 PyObject *resultobj = 0;
5340 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5341 double arg2 ;
5342 void *argp1 = 0 ;
5343 int res1 = 0 ;
5344 double val2 ;
5345 int ecode2 = 0 ;
5346 PyObject *swig_obj[2] ;
5347
5348 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5350 if (!SWIG_IsOK(res1)) {
5351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5352 }
5353 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5354 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5355 if (!SWIG_IsOK(ecode2)) {
5356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5357 }
5358 arg2 = static_cast< double >(val2);
5359 if (arg1) (arg1)->y = arg2;
5360
5361 resultobj = SWIG_Py_Void();
5362 return resultobj;
5363 fail:
5364 return NULL;
5365 }
5366
5367
5368 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 PyObject *resultobj = 0;
5370 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5371 double result;
5372 void *argp1 = 0 ;
5373 int res1 = 0 ;
5374 PyObject *swig_obj[1] ;
5375
5376 if (!args) SWIG_fail;
5377 swig_obj[0] = args;
5378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5379 if (!SWIG_IsOK(res1)) {
5380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5381 }
5382 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5383 result = (double) ((arg1)->y);
5384 resultobj = SWIG_From_double(static_cast< double >(result));
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5392 PyObject *resultobj = 0;
5393 double arg1 = (double) 0.0 ;
5394 double arg2 = (double) 0.0 ;
5395 wxRealPoint *result = 0 ;
5396 double val1 ;
5397 int ecode1 = 0 ;
5398 double val2 ;
5399 int ecode2 = 0 ;
5400 PyObject * obj0 = 0 ;
5401 PyObject * obj1 = 0 ;
5402 char * kwnames[] = {
5403 (char *) "x",(char *) "y", NULL
5404 };
5405
5406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5407 if (obj0) {
5408 ecode1 = SWIG_AsVal_double(obj0, &val1);
5409 if (!SWIG_IsOK(ecode1)) {
5410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5411 }
5412 arg1 = static_cast< double >(val1);
5413 }
5414 if (obj1) {
5415 ecode2 = SWIG_AsVal_double(obj1, &val2);
5416 if (!SWIG_IsOK(ecode2)) {
5417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5418 }
5419 arg2 = static_cast< double >(val2);
5420 }
5421 {
5422 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5423 if (PyErr_Occurred()) SWIG_fail;
5424 }
5425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5435 void *argp1 = 0 ;
5436 int res1 = 0 ;
5437 PyObject *swig_obj[1] ;
5438
5439 if (!args) SWIG_fail;
5440 swig_obj[0] = args;
5441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 {
5447 delete arg1;
5448
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 resultobj = SWIG_Py_Void();
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj = 0;
5460 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5461 PyObject *arg2 = (PyObject *) 0 ;
5462 bool result;
5463 void *argp1 = 0 ;
5464 int res1 = 0 ;
5465 PyObject * obj0 = 0 ;
5466 PyObject * obj1 = 0 ;
5467 char * kwnames[] = {
5468 (char *) "self",(char *) "other", NULL
5469 };
5470
5471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5473 if (!SWIG_IsOK(res1)) {
5474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5475 }
5476 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5477 arg2 = obj1;
5478 {
5479 result = (bool)wxRealPoint___eq__(arg1,arg2);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5484 }
5485 return resultobj;
5486 fail:
5487 return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5492 PyObject *resultobj = 0;
5493 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5494 PyObject *arg2 = (PyObject *) 0 ;
5495 bool result;
5496 void *argp1 = 0 ;
5497 int res1 = 0 ;
5498 PyObject * obj0 = 0 ;
5499 PyObject * obj1 = 0 ;
5500 char * kwnames[] = {
5501 (char *) "self",(char *) "other", NULL
5502 };
5503
5504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 arg2 = obj1;
5511 {
5512 result = (bool)wxRealPoint___ne__(arg1,arg2);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5527 wxRealPoint *arg2 = 0 ;
5528 wxRealPoint result;
5529 void *argp1 = 0 ;
5530 int res1 = 0 ;
5531 wxRealPoint temp2 ;
5532 PyObject * obj0 = 0 ;
5533 PyObject * obj1 = 0 ;
5534 char * kwnames[] = {
5535 (char *) "self",(char *) "pt", NULL
5536 };
5537
5538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 {
5545 arg2 = &temp2;
5546 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5547 }
5548 {
5549 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5550 if (PyErr_Occurred()) SWIG_fail;
5551 }
5552 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5553 return resultobj;
5554 fail:
5555 return NULL;
5556 }
5557
5558
5559 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5560 PyObject *resultobj = 0;
5561 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5562 wxRealPoint *arg2 = 0 ;
5563 wxRealPoint result;
5564 void *argp1 = 0 ;
5565 int res1 = 0 ;
5566 wxRealPoint temp2 ;
5567 PyObject * obj0 = 0 ;
5568 PyObject * obj1 = 0 ;
5569 char * kwnames[] = {
5570 (char *) "self",(char *) "pt", NULL
5571 };
5572
5573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5579 {
5580 arg2 = &temp2;
5581 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5582 }
5583 {
5584 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5585 if (PyErr_Occurred()) SWIG_fail;
5586 }
5587 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5595 PyObject *resultobj = 0;
5596 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5597 double arg2 ;
5598 double arg3 ;
5599 void *argp1 = 0 ;
5600 int res1 = 0 ;
5601 double val2 ;
5602 int ecode2 = 0 ;
5603 double val3 ;
5604 int ecode3 = 0 ;
5605 PyObject * obj0 = 0 ;
5606 PyObject * obj1 = 0 ;
5607 PyObject * obj2 = 0 ;
5608 char * kwnames[] = {
5609 (char *) "self",(char *) "x",(char *) "y", NULL
5610 };
5611
5612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5614 if (!SWIG_IsOK(res1)) {
5615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5616 }
5617 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5618 ecode2 = SWIG_AsVal_double(obj1, &val2);
5619 if (!SWIG_IsOK(ecode2)) {
5620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5621 }
5622 arg2 = static_cast< double >(val2);
5623 ecode3 = SWIG_AsVal_double(obj2, &val3);
5624 if (!SWIG_IsOK(ecode3)) {
5625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5626 }
5627 arg3 = static_cast< double >(val3);
5628 {
5629 wxRealPoint_Set(arg1,arg2,arg3);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 resultobj = SWIG_Py_Void();
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5640 PyObject *resultobj = 0;
5641 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5642 PyObject *result = 0 ;
5643 void *argp1 = 0 ;
5644 int res1 = 0 ;
5645 PyObject *swig_obj[1] ;
5646
5647 if (!args) SWIG_fail;
5648 swig_obj[0] = args;
5649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5650 if (!SWIG_IsOK(res1)) {
5651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5652 }
5653 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5654 {
5655 result = (PyObject *)wxRealPoint_Get(arg1);
5656 if (PyErr_Occurred()) SWIG_fail;
5657 }
5658 resultobj = result;
5659 return resultobj;
5660 fail:
5661 return NULL;
5662 }
5663
5664
5665 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5666 PyObject *obj;
5667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5668 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5669 return SWIG_Py_Void();
5670 }
5671
5672 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5673 return SWIG_Python_InitShadowInstance(args);
5674 }
5675
5676 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5677 PyObject *resultobj = 0;
5678 wxPoint *arg1 = (wxPoint *) 0 ;
5679 int arg2 ;
5680 void *argp1 = 0 ;
5681 int res1 = 0 ;
5682 int val2 ;
5683 int ecode2 = 0 ;
5684 PyObject *swig_obj[2] ;
5685
5686 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5688 if (!SWIG_IsOK(res1)) {
5689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5690 }
5691 arg1 = reinterpret_cast< wxPoint * >(argp1);
5692 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5693 if (!SWIG_IsOK(ecode2)) {
5694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5695 }
5696 arg2 = static_cast< int >(val2);
5697 if (arg1) (arg1)->x = arg2;
5698
5699 resultobj = SWIG_Py_Void();
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5707 PyObject *resultobj = 0;
5708 wxPoint *arg1 = (wxPoint *) 0 ;
5709 int result;
5710 void *argp1 = 0 ;
5711 int res1 = 0 ;
5712 PyObject *swig_obj[1] ;
5713
5714 if (!args) SWIG_fail;
5715 swig_obj[0] = args;
5716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5717 if (!SWIG_IsOK(res1)) {
5718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5719 }
5720 arg1 = reinterpret_cast< wxPoint * >(argp1);
5721 result = (int) ((arg1)->x);
5722 resultobj = SWIG_From_int(static_cast< int >(result));
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *resultobj = 0;
5731 wxPoint *arg1 = (wxPoint *) 0 ;
5732 int arg2 ;
5733 void *argp1 = 0 ;
5734 int res1 = 0 ;
5735 int val2 ;
5736 int ecode2 = 0 ;
5737 PyObject *swig_obj[2] ;
5738
5739 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5741 if (!SWIG_IsOK(res1)) {
5742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5743 }
5744 arg1 = reinterpret_cast< wxPoint * >(argp1);
5745 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5746 if (!SWIG_IsOK(ecode2)) {
5747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5748 }
5749 arg2 = static_cast< int >(val2);
5750 if (arg1) (arg1)->y = arg2;
5751
5752 resultobj = SWIG_Py_Void();
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5760 PyObject *resultobj = 0;
5761 wxPoint *arg1 = (wxPoint *) 0 ;
5762 int result;
5763 void *argp1 = 0 ;
5764 int res1 = 0 ;
5765 PyObject *swig_obj[1] ;
5766
5767 if (!args) SWIG_fail;
5768 swig_obj[0] = args;
5769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5770 if (!SWIG_IsOK(res1)) {
5771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5772 }
5773 arg1 = reinterpret_cast< wxPoint * >(argp1);
5774 result = (int) ((arg1)->y);
5775 resultobj = SWIG_From_int(static_cast< int >(result));
5776 return resultobj;
5777 fail:
5778 return NULL;
5779 }
5780
5781
5782 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5783 PyObject *resultobj = 0;
5784 int arg1 = (int) 0 ;
5785 int arg2 = (int) 0 ;
5786 wxPoint *result = 0 ;
5787 int val1 ;
5788 int ecode1 = 0 ;
5789 int val2 ;
5790 int ecode2 = 0 ;
5791 PyObject * obj0 = 0 ;
5792 PyObject * obj1 = 0 ;
5793 char * kwnames[] = {
5794 (char *) "x",(char *) "y", NULL
5795 };
5796
5797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5798 if (obj0) {
5799 ecode1 = SWIG_AsVal_int(obj0, &val1);
5800 if (!SWIG_IsOK(ecode1)) {
5801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5802 }
5803 arg1 = static_cast< int >(val1);
5804 }
5805 if (obj1) {
5806 ecode2 = SWIG_AsVal_int(obj1, &val2);
5807 if (!SWIG_IsOK(ecode2)) {
5808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5809 }
5810 arg2 = static_cast< int >(val2);
5811 }
5812 {
5813 result = (wxPoint *)new wxPoint(arg1,arg2);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5824 PyObject *resultobj = 0;
5825 wxPoint *arg1 = (wxPoint *) 0 ;
5826 void *argp1 = 0 ;
5827 int res1 = 0 ;
5828 PyObject *swig_obj[1] ;
5829
5830 if (!args) SWIG_fail;
5831 swig_obj[0] = args;
5832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 {
5838 delete arg1;
5839
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_Py_Void();
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 PyObject *arg2 = (PyObject *) 0 ;
5853 bool result;
5854 void *argp1 = 0 ;
5855 int res1 = 0 ;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 char * kwnames[] = {
5859 (char *) "self",(char *) "other", NULL
5860 };
5861
5862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5864 if (!SWIG_IsOK(res1)) {
5865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5866 }
5867 arg1 = reinterpret_cast< wxPoint * >(argp1);
5868 arg2 = obj1;
5869 {
5870 result = (bool)wxPoint___eq__(arg1,arg2);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 {
5874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5875 }
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj = 0;
5884 wxPoint *arg1 = (wxPoint *) 0 ;
5885 PyObject *arg2 = (PyObject *) 0 ;
5886 bool result;
5887 void *argp1 = 0 ;
5888 int res1 = 0 ;
5889 PyObject * obj0 = 0 ;
5890 PyObject * obj1 = 0 ;
5891 char * kwnames[] = {
5892 (char *) "self",(char *) "other", NULL
5893 };
5894
5895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5897 if (!SWIG_IsOK(res1)) {
5898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5899 }
5900 arg1 = reinterpret_cast< wxPoint * >(argp1);
5901 arg2 = obj1;
5902 {
5903 result = (bool)wxPoint___ne__(arg1,arg2);
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 {
5907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5908 }
5909 return resultobj;
5910 fail:
5911 return NULL;
5912 }
5913
5914
5915 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5916 PyObject *resultobj = 0;
5917 wxPoint *arg1 = (wxPoint *) 0 ;
5918 wxPoint *arg2 = 0 ;
5919 wxPoint result;
5920 void *argp1 = 0 ;
5921 int res1 = 0 ;
5922 wxPoint temp2 ;
5923 PyObject * obj0 = 0 ;
5924 PyObject * obj1 = 0 ;
5925 char * kwnames[] = {
5926 (char *) "self",(char *) "pt", NULL
5927 };
5928
5929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5931 if (!SWIG_IsOK(res1)) {
5932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5933 }
5934 arg1 = reinterpret_cast< wxPoint * >(argp1);
5935 {
5936 arg2 = &temp2;
5937 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5938 }
5939 {
5940 result = (arg1)->operator +((wxPoint const &)*arg2);
5941 if (PyErr_Occurred()) SWIG_fail;
5942 }
5943 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5944 return resultobj;
5945 fail:
5946 return NULL;
5947 }
5948
5949
5950 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5951 PyObject *resultobj = 0;
5952 wxPoint *arg1 = (wxPoint *) 0 ;
5953 wxPoint *arg2 = 0 ;
5954 wxPoint result;
5955 void *argp1 = 0 ;
5956 int res1 = 0 ;
5957 wxPoint temp2 ;
5958 PyObject * obj0 = 0 ;
5959 PyObject * obj1 = 0 ;
5960 char * kwnames[] = {
5961 (char *) "self",(char *) "pt", NULL
5962 };
5963
5964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5966 if (!SWIG_IsOK(res1)) {
5967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5968 }
5969 arg1 = reinterpret_cast< wxPoint * >(argp1);
5970 {
5971 arg2 = &temp2;
5972 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5973 }
5974 {
5975 result = (arg1)->operator -((wxPoint const &)*arg2);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj = 0;
5987 wxPoint *arg1 = (wxPoint *) 0 ;
5988 wxPoint *arg2 = 0 ;
5989 wxPoint *result = 0 ;
5990 void *argp1 = 0 ;
5991 int res1 = 0 ;
5992 wxPoint temp2 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "self",(char *) "pt", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6001 if (!SWIG_IsOK(res1)) {
6002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6003 }
6004 arg1 = reinterpret_cast< wxPoint * >(argp1);
6005 {
6006 arg2 = &temp2;
6007 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6008 }
6009 {
6010 {
6011 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6012 result = (wxPoint *) &_result_ref;
6013 }
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6017 return resultobj;
6018 fail:
6019 return NULL;
6020 }
6021
6022
6023 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6024 PyObject *resultobj = 0;
6025 wxPoint *arg1 = (wxPoint *) 0 ;
6026 wxPoint *arg2 = 0 ;
6027 wxPoint *result = 0 ;
6028 void *argp1 = 0 ;
6029 int res1 = 0 ;
6030 wxPoint temp2 ;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 char * kwnames[] = {
6034 (char *) "self",(char *) "pt", NULL
6035 };
6036
6037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6039 if (!SWIG_IsOK(res1)) {
6040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6041 }
6042 arg1 = reinterpret_cast< wxPoint * >(argp1);
6043 {
6044 arg2 = &temp2;
6045 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6046 }
6047 {
6048 {
6049 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6050 result = (wxPoint *) &_result_ref;
6051 }
6052 if (PyErr_Occurred()) SWIG_fail;
6053 }
6054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6055 return resultobj;
6056 fail:
6057 return NULL;
6058 }
6059
6060
6061 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6062 PyObject *resultobj = 0;
6063 wxPoint *arg1 = (wxPoint *) 0 ;
6064 long arg2 ;
6065 long arg3 ;
6066 void *argp1 = 0 ;
6067 int res1 = 0 ;
6068 long val2 ;
6069 int ecode2 = 0 ;
6070 long val3 ;
6071 int ecode3 = 0 ;
6072 PyObject * obj0 = 0 ;
6073 PyObject * obj1 = 0 ;
6074 PyObject * obj2 = 0 ;
6075 char * kwnames[] = {
6076 (char *) "self",(char *) "x",(char *) "y", NULL
6077 };
6078
6079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6081 if (!SWIG_IsOK(res1)) {
6082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6083 }
6084 arg1 = reinterpret_cast< wxPoint * >(argp1);
6085 ecode2 = SWIG_AsVal_long(obj1, &val2);
6086 if (!SWIG_IsOK(ecode2)) {
6087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6088 }
6089 arg2 = static_cast< long >(val2);
6090 ecode3 = SWIG_AsVal_long(obj2, &val3);
6091 if (!SWIG_IsOK(ecode3)) {
6092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6093 }
6094 arg3 = static_cast< long >(val3);
6095 {
6096 wxPoint_Set(arg1,arg2,arg3);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 resultobj = SWIG_Py_Void();
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6107 PyObject *resultobj = 0;
6108 wxPoint *arg1 = (wxPoint *) 0 ;
6109 PyObject *result = 0 ;
6110 void *argp1 = 0 ;
6111 int res1 = 0 ;
6112 PyObject *swig_obj[1] ;
6113
6114 if (!args) SWIG_fail;
6115 swig_obj[0] = args;
6116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6117 if (!SWIG_IsOK(res1)) {
6118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6119 }
6120 arg1 = reinterpret_cast< wxPoint * >(argp1);
6121 {
6122 result = (PyObject *)wxPoint_Get(arg1);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 resultobj = result;
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6133 PyObject *obj;
6134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6135 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6136 return SWIG_Py_Void();
6137 }
6138
6139 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6140 return SWIG_Python_InitShadowInstance(args);
6141 }
6142
6143 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6144 PyObject *resultobj = 0;
6145 int arg1 = (int) 0 ;
6146 int arg2 = (int) 0 ;
6147 int arg3 = (int) 0 ;
6148 int arg4 = (int) 0 ;
6149 wxRect *result = 0 ;
6150 int val1 ;
6151 int ecode1 = 0 ;
6152 int val2 ;
6153 int ecode2 = 0 ;
6154 int val3 ;
6155 int ecode3 = 0 ;
6156 int val4 ;
6157 int ecode4 = 0 ;
6158 PyObject * obj0 = 0 ;
6159 PyObject * obj1 = 0 ;
6160 PyObject * obj2 = 0 ;
6161 PyObject * obj3 = 0 ;
6162 char * kwnames[] = {
6163 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6164 };
6165
6166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6167 if (obj0) {
6168 ecode1 = SWIG_AsVal_int(obj0, &val1);
6169 if (!SWIG_IsOK(ecode1)) {
6170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6171 }
6172 arg1 = static_cast< int >(val1);
6173 }
6174 if (obj1) {
6175 ecode2 = SWIG_AsVal_int(obj1, &val2);
6176 if (!SWIG_IsOK(ecode2)) {
6177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6178 }
6179 arg2 = static_cast< int >(val2);
6180 }
6181 if (obj2) {
6182 ecode3 = SWIG_AsVal_int(obj2, &val3);
6183 if (!SWIG_IsOK(ecode3)) {
6184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6185 }
6186 arg3 = static_cast< int >(val3);
6187 }
6188 if (obj3) {
6189 ecode4 = SWIG_AsVal_int(obj3, &val4);
6190 if (!SWIG_IsOK(ecode4)) {
6191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6192 }
6193 arg4 = static_cast< int >(val4);
6194 }
6195 {
6196 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxPoint *arg1 = 0 ;
6209 wxPoint *arg2 = 0 ;
6210 wxRect *result = 0 ;
6211 wxPoint temp1 ;
6212 wxPoint temp2 ;
6213 PyObject * obj0 = 0 ;
6214 PyObject * obj1 = 0 ;
6215 char * kwnames[] = {
6216 (char *) "topLeft",(char *) "bottomRight", NULL
6217 };
6218
6219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6220 {
6221 arg1 = &temp1;
6222 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6223 }
6224 {
6225 arg2 = &temp2;
6226 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6227 }
6228 {
6229 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj = 0;
6241 wxPoint *arg1 = 0 ;
6242 wxSize *arg2 = 0 ;
6243 wxRect *result = 0 ;
6244 wxPoint temp1 ;
6245 wxSize temp2 ;
6246 PyObject * obj0 = 0 ;
6247 PyObject * obj1 = 0 ;
6248 char * kwnames[] = {
6249 (char *) "pos",(char *) "size", NULL
6250 };
6251
6252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6253 {
6254 arg1 = &temp1;
6255 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6256 }
6257 {
6258 arg2 = &temp2;
6259 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6260 }
6261 {
6262 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6263 if (PyErr_Occurred()) SWIG_fail;
6264 }
6265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6266 return resultobj;
6267 fail:
6268 return NULL;
6269 }
6270
6271
6272 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6273 PyObject *resultobj = 0;
6274 wxSize *arg1 = 0 ;
6275 wxRect *result = 0 ;
6276 wxSize temp1 ;
6277 PyObject * obj0 = 0 ;
6278 char * kwnames[] = {
6279 (char *) "size", NULL
6280 };
6281
6282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6283 {
6284 arg1 = &temp1;
6285 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6286 }
6287 {
6288 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6289 if (PyErr_Occurred()) SWIG_fail;
6290 }
6291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6292 return resultobj;
6293 fail:
6294 return NULL;
6295 }
6296
6297
6298 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6299 PyObject *resultobj = 0;
6300 wxRect *arg1 = (wxRect *) 0 ;
6301 void *argp1 = 0 ;
6302 int res1 = 0 ;
6303 PyObject *swig_obj[1] ;
6304
6305 if (!args) SWIG_fail;
6306 swig_obj[0] = args;
6307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6308 if (!SWIG_IsOK(res1)) {
6309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6310 }
6311 arg1 = reinterpret_cast< wxRect * >(argp1);
6312 {
6313 delete arg1;
6314
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 resultobj = SWIG_Py_Void();
6318 return resultobj;
6319 fail:
6320 return NULL;
6321 }
6322
6323
6324 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6325 PyObject *resultobj = 0;
6326 wxRect *arg1 = (wxRect *) 0 ;
6327 int result;
6328 void *argp1 = 0 ;
6329 int res1 = 0 ;
6330 PyObject *swig_obj[1] ;
6331
6332 if (!args) SWIG_fail;
6333 swig_obj[0] = args;
6334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6335 if (!SWIG_IsOK(res1)) {
6336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6337 }
6338 arg1 = reinterpret_cast< wxRect * >(argp1);
6339 {
6340 result = (int)((wxRect const *)arg1)->GetX();
6341 if (PyErr_Occurred()) SWIG_fail;
6342 }
6343 resultobj = SWIG_From_int(static_cast< int >(result));
6344 return resultobj;
6345 fail:
6346 return NULL;
6347 }
6348
6349
6350 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6351 PyObject *resultobj = 0;
6352 wxRect *arg1 = (wxRect *) 0 ;
6353 int arg2 ;
6354 void *argp1 = 0 ;
6355 int res1 = 0 ;
6356 int val2 ;
6357 int ecode2 = 0 ;
6358 PyObject * obj0 = 0 ;
6359 PyObject * obj1 = 0 ;
6360 char * kwnames[] = {
6361 (char *) "self",(char *) "x", NULL
6362 };
6363
6364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6366 if (!SWIG_IsOK(res1)) {
6367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6368 }
6369 arg1 = reinterpret_cast< wxRect * >(argp1);
6370 ecode2 = SWIG_AsVal_int(obj1, &val2);
6371 if (!SWIG_IsOK(ecode2)) {
6372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6373 }
6374 arg2 = static_cast< int >(val2);
6375 {
6376 (arg1)->SetX(arg2);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 resultobj = SWIG_Py_Void();
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6387 PyObject *resultobj = 0;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int result;
6390 void *argp1 = 0 ;
6391 int res1 = 0 ;
6392 PyObject *swig_obj[1] ;
6393
6394 if (!args) SWIG_fail;
6395 swig_obj[0] = args;
6396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6397 if (!SWIG_IsOK(res1)) {
6398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6399 }
6400 arg1 = reinterpret_cast< wxRect * >(argp1);
6401 {
6402 result = (int)(arg1)->GetY();
6403 if (PyErr_Occurred()) SWIG_fail;
6404 }
6405 resultobj = SWIG_From_int(static_cast< int >(result));
6406 return resultobj;
6407 fail:
6408 return NULL;
6409 }
6410
6411
6412 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6413 PyObject *resultobj = 0;
6414 wxRect *arg1 = (wxRect *) 0 ;
6415 int arg2 ;
6416 void *argp1 = 0 ;
6417 int res1 = 0 ;
6418 int val2 ;
6419 int ecode2 = 0 ;
6420 PyObject * obj0 = 0 ;
6421 PyObject * obj1 = 0 ;
6422 char * kwnames[] = {
6423 (char *) "self",(char *) "y", NULL
6424 };
6425
6426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6428 if (!SWIG_IsOK(res1)) {
6429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6430 }
6431 arg1 = reinterpret_cast< wxRect * >(argp1);
6432 ecode2 = SWIG_AsVal_int(obj1, &val2);
6433 if (!SWIG_IsOK(ecode2)) {
6434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6435 }
6436 arg2 = static_cast< int >(val2);
6437 {
6438 (arg1)->SetY(arg2);
6439 if (PyErr_Occurred()) SWIG_fail;
6440 }
6441 resultobj = SWIG_Py_Void();
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6449 PyObject *resultobj = 0;
6450 wxRect *arg1 = (wxRect *) 0 ;
6451 int result;
6452 void *argp1 = 0 ;
6453 int res1 = 0 ;
6454 PyObject *swig_obj[1] ;
6455
6456 if (!args) SWIG_fail;
6457 swig_obj[0] = args;
6458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6459 if (!SWIG_IsOK(res1)) {
6460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6461 }
6462 arg1 = reinterpret_cast< wxRect * >(argp1);
6463 {
6464 result = (int)((wxRect const *)arg1)->GetWidth();
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_From_int(static_cast< int >(result));
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6475 PyObject *resultobj = 0;
6476 wxRect *arg1 = (wxRect *) 0 ;
6477 int arg2 ;
6478 void *argp1 = 0 ;
6479 int res1 = 0 ;
6480 int val2 ;
6481 int ecode2 = 0 ;
6482 PyObject * obj0 = 0 ;
6483 PyObject * obj1 = 0 ;
6484 char * kwnames[] = {
6485 (char *) "self",(char *) "w", NULL
6486 };
6487
6488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6490 if (!SWIG_IsOK(res1)) {
6491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6492 }
6493 arg1 = reinterpret_cast< wxRect * >(argp1);
6494 ecode2 = SWIG_AsVal_int(obj1, &val2);
6495 if (!SWIG_IsOK(ecode2)) {
6496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6497 }
6498 arg2 = static_cast< int >(val2);
6499 {
6500 (arg1)->SetWidth(arg2);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 resultobj = SWIG_Py_Void();
6504 return resultobj;
6505 fail:
6506 return NULL;
6507 }
6508
6509
6510 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6511 PyObject *resultobj = 0;
6512 wxRect *arg1 = (wxRect *) 0 ;
6513 int result;
6514 void *argp1 = 0 ;
6515 int res1 = 0 ;
6516 PyObject *swig_obj[1] ;
6517
6518 if (!args) SWIG_fail;
6519 swig_obj[0] = args;
6520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6521 if (!SWIG_IsOK(res1)) {
6522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6523 }
6524 arg1 = reinterpret_cast< wxRect * >(argp1);
6525 {
6526 result = (int)((wxRect const *)arg1)->GetHeight();
6527 if (PyErr_Occurred()) SWIG_fail;
6528 }
6529 resultobj = SWIG_From_int(static_cast< int >(result));
6530 return resultobj;
6531 fail:
6532 return NULL;
6533 }
6534
6535
6536 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6537 PyObject *resultobj = 0;
6538 wxRect *arg1 = (wxRect *) 0 ;
6539 int arg2 ;
6540 void *argp1 = 0 ;
6541 int res1 = 0 ;
6542 int val2 ;
6543 int ecode2 = 0 ;
6544 PyObject * obj0 = 0 ;
6545 PyObject * obj1 = 0 ;
6546 char * kwnames[] = {
6547 (char *) "self",(char *) "h", NULL
6548 };
6549
6550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6552 if (!SWIG_IsOK(res1)) {
6553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6554 }
6555 arg1 = reinterpret_cast< wxRect * >(argp1);
6556 ecode2 = SWIG_AsVal_int(obj1, &val2);
6557 if (!SWIG_IsOK(ecode2)) {
6558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6559 }
6560 arg2 = static_cast< int >(val2);
6561 {
6562 (arg1)->SetHeight(arg2);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 resultobj = SWIG_Py_Void();
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6573 PyObject *resultobj = 0;
6574 wxRect *arg1 = (wxRect *) 0 ;
6575 wxPoint result;
6576 void *argp1 = 0 ;
6577 int res1 = 0 ;
6578 PyObject *swig_obj[1] ;
6579
6580 if (!args) SWIG_fail;
6581 swig_obj[0] = args;
6582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6583 if (!SWIG_IsOK(res1)) {
6584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6585 }
6586 arg1 = reinterpret_cast< wxRect * >(argp1);
6587 {
6588 result = ((wxRect const *)arg1)->GetPosition();
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj = 0;
6600 wxRect *arg1 = (wxRect *) 0 ;
6601 wxPoint *arg2 = 0 ;
6602 void *argp1 = 0 ;
6603 int res1 = 0 ;
6604 wxPoint temp2 ;
6605 PyObject * obj0 = 0 ;
6606 PyObject * obj1 = 0 ;
6607 char * kwnames[] = {
6608 (char *) "self",(char *) "p", NULL
6609 };
6610
6611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6615 }
6616 arg1 = reinterpret_cast< wxRect * >(argp1);
6617 {
6618 arg2 = &temp2;
6619 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6620 }
6621 {
6622 (arg1)->SetPosition((wxPoint const &)*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_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 wxSize 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_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6645 }
6646 arg1 = reinterpret_cast< wxRect * >(argp1);
6647 {
6648 result = ((wxRect const *)arg1)->GetSize();
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj = 0;
6660 wxRect *arg1 = (wxRect *) 0 ;
6661 wxSize *arg2 = 0 ;
6662 void *argp1 = 0 ;
6663 int res1 = 0 ;
6664 wxSize temp2 ;
6665 PyObject * obj0 = 0 ;
6666 PyObject * obj1 = 0 ;
6667 char * kwnames[] = {
6668 (char *) "self",(char *) "s", NULL
6669 };
6670
6671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6673 if (!SWIG_IsOK(res1)) {
6674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6675 }
6676 arg1 = reinterpret_cast< wxRect * >(argp1);
6677 {
6678 arg2 = &temp2;
6679 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6680 }
6681 {
6682 (arg1)->SetSize((wxSize const &)*arg2);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = SWIG_Py_Void();
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6693 PyObject *resultobj = 0;
6694 wxRect *arg1 = (wxRect *) 0 ;
6695 bool result;
6696 void *argp1 = 0 ;
6697 int res1 = 0 ;
6698 PyObject *swig_obj[1] ;
6699
6700 if (!args) SWIG_fail;
6701 swig_obj[0] = args;
6702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6703 if (!SWIG_IsOK(res1)) {
6704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6705 }
6706 arg1 = reinterpret_cast< wxRect * >(argp1);
6707 {
6708 result = (bool)((wxRect const *)arg1)->IsEmpty();
6709 if (PyErr_Occurred()) SWIG_fail;
6710 }
6711 {
6712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6713 }
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6721 PyObject *resultobj = 0;
6722 wxRect *arg1 = (wxRect *) 0 ;
6723 wxPoint result;
6724 void *argp1 = 0 ;
6725 int res1 = 0 ;
6726 PyObject *swig_obj[1] ;
6727
6728 if (!args) SWIG_fail;
6729 swig_obj[0] = args;
6730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6731 if (!SWIG_IsOK(res1)) {
6732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6733 }
6734 arg1 = reinterpret_cast< wxRect * >(argp1);
6735 {
6736 result = ((wxRect const *)arg1)->GetTopLeft();
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6747 PyObject *resultobj = 0;
6748 wxRect *arg1 = (wxRect *) 0 ;
6749 wxPoint *arg2 = 0 ;
6750 void *argp1 = 0 ;
6751 int res1 = 0 ;
6752 wxPoint temp2 ;
6753 PyObject * obj0 = 0 ;
6754 PyObject * obj1 = 0 ;
6755 char * kwnames[] = {
6756 (char *) "self",(char *) "p", NULL
6757 };
6758
6759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6763 }
6764 arg1 = reinterpret_cast< wxRect * >(argp1);
6765 {
6766 arg2 = &temp2;
6767 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6768 }
6769 {
6770 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 resultobj = SWIG_Py_Void();
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxPoint result;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 PyObject *swig_obj[1] ;
6787
6788 if (!args) SWIG_fail;
6789 swig_obj[0] = args;
6790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 result = ((wxRect const *)arg1)->GetBottomRight();
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj = 0;
6808 wxRect *arg1 = (wxRect *) 0 ;
6809 wxPoint *arg2 = 0 ;
6810 void *argp1 = 0 ;
6811 int res1 = 0 ;
6812 wxPoint temp2 ;
6813 PyObject * obj0 = 0 ;
6814 PyObject * obj1 = 0 ;
6815 char * kwnames[] = {
6816 (char *) "self",(char *) "p", NULL
6817 };
6818
6819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6821 if (!SWIG_IsOK(res1)) {
6822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6823 }
6824 arg1 = reinterpret_cast< wxRect * >(argp1);
6825 {
6826 arg2 = &temp2;
6827 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6828 }
6829 {
6830 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_Py_Void();
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 wxPoint result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 result = ((wxRect const *)arg1)->GetTopRight();
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6867 PyObject *resultobj = 0;
6868 wxRect *arg1 = (wxRect *) 0 ;
6869 wxPoint *arg2 = 0 ;
6870 void *argp1 = 0 ;
6871 int res1 = 0 ;
6872 wxPoint temp2 ;
6873 PyObject * obj0 = 0 ;
6874 PyObject * obj1 = 0 ;
6875 char * kwnames[] = {
6876 (char *) "self",(char *) "p", NULL
6877 };
6878
6879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6881 if (!SWIG_IsOK(res1)) {
6882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6883 }
6884 arg1 = reinterpret_cast< wxRect * >(argp1);
6885 {
6886 arg2 = &temp2;
6887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6888 }
6889 {
6890 (arg1)->SetTopRight((wxPoint const &)*arg2);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6901 PyObject *resultobj = 0;
6902 wxRect *arg1 = (wxRect *) 0 ;
6903 wxPoint result;
6904 void *argp1 = 0 ;
6905 int res1 = 0 ;
6906 PyObject *swig_obj[1] ;
6907
6908 if (!args) SWIG_fail;
6909 swig_obj[0] = args;
6910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6911 if (!SWIG_IsOK(res1)) {
6912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6913 }
6914 arg1 = reinterpret_cast< wxRect * >(argp1);
6915 {
6916 result = ((wxRect const *)arg1)->GetBottomLeft();
6917 if (PyErr_Occurred()) SWIG_fail;
6918 }
6919 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6920 return resultobj;
6921 fail:
6922 return NULL;
6923 }
6924
6925
6926 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6927 PyObject *resultobj = 0;
6928 wxRect *arg1 = (wxRect *) 0 ;
6929 wxPoint *arg2 = 0 ;
6930 void *argp1 = 0 ;
6931 int res1 = 0 ;
6932 wxPoint temp2 ;
6933 PyObject * obj0 = 0 ;
6934 PyObject * obj1 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "self",(char *) "p", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6943 }
6944 arg1 = reinterpret_cast< wxRect * >(argp1);
6945 {
6946 arg2 = &temp2;
6947 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6948 }
6949 {
6950 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6951 if (PyErr_Occurred()) SWIG_fail;
6952 }
6953 resultobj = SWIG_Py_Void();
6954 return resultobj;
6955 fail:
6956 return NULL;
6957 }
6958
6959
6960 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6961 PyObject *resultobj = 0;
6962 wxRect *arg1 = (wxRect *) 0 ;
6963 int result;
6964 void *argp1 = 0 ;
6965 int res1 = 0 ;
6966 PyObject *swig_obj[1] ;
6967
6968 if (!args) SWIG_fail;
6969 swig_obj[0] = args;
6970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6971 if (!SWIG_IsOK(res1)) {
6972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6973 }
6974 arg1 = reinterpret_cast< wxRect * >(argp1);
6975 {
6976 result = (int)((wxRect const *)arg1)->GetLeft();
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_From_int(static_cast< int >(result));
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6987 PyObject *resultobj = 0;
6988 wxRect *arg1 = (wxRect *) 0 ;
6989 int result;
6990 void *argp1 = 0 ;
6991 int res1 = 0 ;
6992 PyObject *swig_obj[1] ;
6993
6994 if (!args) SWIG_fail;
6995 swig_obj[0] = args;
6996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6997 if (!SWIG_IsOK(res1)) {
6998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6999 }
7000 arg1 = reinterpret_cast< wxRect * >(argp1);
7001 {
7002 result = (int)((wxRect const *)arg1)->GetTop();
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_From_int(static_cast< int >(result));
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7013 PyObject *resultobj = 0;
7014 wxRect *arg1 = (wxRect *) 0 ;
7015 int result;
7016 void *argp1 = 0 ;
7017 int res1 = 0 ;
7018 PyObject *swig_obj[1] ;
7019
7020 if (!args) SWIG_fail;
7021 swig_obj[0] = args;
7022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7023 if (!SWIG_IsOK(res1)) {
7024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7025 }
7026 arg1 = reinterpret_cast< wxRect * >(argp1);
7027 {
7028 result = (int)((wxRect const *)arg1)->GetBottom();
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_From_int(static_cast< int >(result));
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7039 PyObject *resultobj = 0;
7040 wxRect *arg1 = (wxRect *) 0 ;
7041 int result;
7042 void *argp1 = 0 ;
7043 int res1 = 0 ;
7044 PyObject *swig_obj[1] ;
7045
7046 if (!args) SWIG_fail;
7047 swig_obj[0] = args;
7048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7049 if (!SWIG_IsOK(res1)) {
7050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7051 }
7052 arg1 = reinterpret_cast< wxRect * >(argp1);
7053 {
7054 result = (int)((wxRect const *)arg1)->GetRight();
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_From_int(static_cast< int >(result));
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 int arg2 ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 int val2 ;
7071 int ecode2 = 0 ;
7072 PyObject * obj0 = 0 ;
7073 PyObject * obj1 = 0 ;
7074 char * kwnames[] = {
7075 (char *) "self",(char *) "left", NULL
7076 };
7077
7078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7080 if (!SWIG_IsOK(res1)) {
7081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7082 }
7083 arg1 = reinterpret_cast< wxRect * >(argp1);
7084 ecode2 = SWIG_AsVal_int(obj1, &val2);
7085 if (!SWIG_IsOK(ecode2)) {
7086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7087 }
7088 arg2 = static_cast< int >(val2);
7089 {
7090 (arg1)->SetLeft(arg2);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 resultobj = SWIG_Py_Void();
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7101 PyObject *resultobj = 0;
7102 wxRect *arg1 = (wxRect *) 0 ;
7103 int arg2 ;
7104 void *argp1 = 0 ;
7105 int res1 = 0 ;
7106 int val2 ;
7107 int ecode2 = 0 ;
7108 PyObject * obj0 = 0 ;
7109 PyObject * obj1 = 0 ;
7110 char * kwnames[] = {
7111 (char *) "self",(char *) "right", NULL
7112 };
7113
7114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7116 if (!SWIG_IsOK(res1)) {
7117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7118 }
7119 arg1 = reinterpret_cast< wxRect * >(argp1);
7120 ecode2 = SWIG_AsVal_int(obj1, &val2);
7121 if (!SWIG_IsOK(ecode2)) {
7122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7123 }
7124 arg2 = static_cast< int >(val2);
7125 {
7126 (arg1)->SetRight(arg2);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_Py_Void();
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj = 0;
7138 wxRect *arg1 = (wxRect *) 0 ;
7139 int arg2 ;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 int val2 ;
7143 int ecode2 = 0 ;
7144 PyObject * obj0 = 0 ;
7145 PyObject * obj1 = 0 ;
7146 char * kwnames[] = {
7147 (char *) "self",(char *) "top", NULL
7148 };
7149
7150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7152 if (!SWIG_IsOK(res1)) {
7153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7154 }
7155 arg1 = reinterpret_cast< wxRect * >(argp1);
7156 ecode2 = SWIG_AsVal_int(obj1, &val2);
7157 if (!SWIG_IsOK(ecode2)) {
7158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7159 }
7160 arg2 = static_cast< int >(val2);
7161 {
7162 (arg1)->SetTop(arg2);
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 resultobj = SWIG_Py_Void();
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj = 0;
7174 wxRect *arg1 = (wxRect *) 0 ;
7175 int arg2 ;
7176 void *argp1 = 0 ;
7177 int res1 = 0 ;
7178 int val2 ;
7179 int ecode2 = 0 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char * kwnames[] = {
7183 (char *) "self",(char *) "bottom", NULL
7184 };
7185
7186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7188 if (!SWIG_IsOK(res1)) {
7189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7190 }
7191 arg1 = reinterpret_cast< wxRect * >(argp1);
7192 ecode2 = SWIG_AsVal_int(obj1, &val2);
7193 if (!SWIG_IsOK(ecode2)) {
7194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7195 }
7196 arg2 = static_cast< int >(val2);
7197 {
7198 (arg1)->SetBottom(arg2);
7199 if (PyErr_Occurred()) SWIG_fail;
7200 }
7201 resultobj = SWIG_Py_Void();
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj = 0;
7210 wxRect *arg1 = (wxRect *) 0 ;
7211 int arg2 ;
7212 int arg3 ;
7213 wxRect *result = 0 ;
7214 void *argp1 = 0 ;
7215 int res1 = 0 ;
7216 int val2 ;
7217 int ecode2 = 0 ;
7218 int val3 ;
7219 int ecode3 = 0 ;
7220 PyObject * obj0 = 0 ;
7221 PyObject * obj1 = 0 ;
7222 PyObject * obj2 = 0 ;
7223 char * kwnames[] = {
7224 (char *) "self",(char *) "dx",(char *) "dy", NULL
7225 };
7226
7227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7229 if (!SWIG_IsOK(res1)) {
7230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7231 }
7232 arg1 = reinterpret_cast< wxRect * >(argp1);
7233 ecode2 = SWIG_AsVal_int(obj1, &val2);
7234 if (!SWIG_IsOK(ecode2)) {
7235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7236 }
7237 arg2 = static_cast< int >(val2);
7238 ecode3 = SWIG_AsVal_int(obj2, &val3);
7239 if (!SWIG_IsOK(ecode3)) {
7240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7241 }
7242 arg3 = static_cast< int >(val3);
7243 {
7244 {
7245 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7246 result = (wxRect *) &_result_ref;
7247 }
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 int arg2 ;
7261 int arg3 ;
7262 wxRect *result = 0 ;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 int val2 ;
7266 int ecode2 = 0 ;
7267 int val3 ;
7268 int ecode3 = 0 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 PyObject * obj2 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "dx",(char *) "dy", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 ecode2 = SWIG_AsVal_int(obj1, &val2);
7283 if (!SWIG_IsOK(ecode2)) {
7284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7285 }
7286 arg2 = static_cast< int >(val2);
7287 ecode3 = SWIG_AsVal_int(obj2, &val3);
7288 if (!SWIG_IsOK(ecode3)) {
7289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7290 }
7291 arg3 = static_cast< int >(val3);
7292 {
7293 {
7294 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7295 result = (wxRect *) &_result_ref;
7296 }
7297 if (PyErr_Occurred()) SWIG_fail;
7298 }
7299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7300 return resultobj;
7301 fail:
7302 return NULL;
7303 }
7304
7305
7306 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7307 PyObject *resultobj = 0;
7308 wxRect *arg1 = (wxRect *) 0 ;
7309 int arg2 ;
7310 int arg3 ;
7311 void *argp1 = 0 ;
7312 int res1 = 0 ;
7313 int val2 ;
7314 int ecode2 = 0 ;
7315 int val3 ;
7316 int ecode3 = 0 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 PyObject * obj2 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "dx",(char *) "dy", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 ecode2 = SWIG_AsVal_int(obj1, &val2);
7331 if (!SWIG_IsOK(ecode2)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7333 }
7334 arg2 = static_cast< int >(val2);
7335 ecode3 = SWIG_AsVal_int(obj2, &val3);
7336 if (!SWIG_IsOK(ecode3)) {
7337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7338 }
7339 arg3 = static_cast< int >(val3);
7340 {
7341 (arg1)->Offset(arg2,arg3);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_Py_Void();
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 wxPoint *arg2 = 0 ;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 wxPoint temp2 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "pt", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 {
7371 arg2 = &temp2;
7372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7373 }
7374 {
7375 (arg1)->Offset((wxPoint const &)*arg2);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 resultobj = SWIG_Py_Void();
7379 return resultobj;
7380 fail:
7381 return NULL;
7382 }
7383
7384
7385 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7386 PyObject *resultobj = 0;
7387 wxRect *arg1 = (wxRect *) 0 ;
7388 wxRect *arg2 = 0 ;
7389 wxRect result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 wxRect temp2 ;
7393 PyObject * obj0 = 0 ;
7394 PyObject * obj1 = 0 ;
7395 char * kwnames[] = {
7396 (char *) "self",(char *) "rect", NULL
7397 };
7398
7399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7401 if (!SWIG_IsOK(res1)) {
7402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7403 }
7404 arg1 = reinterpret_cast< wxRect * >(argp1);
7405 {
7406 arg2 = &temp2;
7407 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7408 }
7409 {
7410 result = (arg1)->Intersect((wxRect const &)*arg2);
7411 if (PyErr_Occurred()) SWIG_fail;
7412 }
7413 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7414 return resultobj;
7415 fail:
7416 return NULL;
7417 }
7418
7419
7420 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7421 PyObject *resultobj = 0;
7422 wxRect *arg1 = (wxRect *) 0 ;
7423 wxRect *arg2 = 0 ;
7424 wxRect result;
7425 void *argp1 = 0 ;
7426 int res1 = 0 ;
7427 wxRect temp2 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 char * kwnames[] = {
7431 (char *) "self",(char *) "rect", NULL
7432 };
7433
7434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7438 }
7439 arg1 = reinterpret_cast< wxRect * >(argp1);
7440 {
7441 arg2 = &temp2;
7442 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7443 }
7444 {
7445 result = (arg1)->Union((wxRect const &)*arg2);
7446 if (PyErr_Occurred()) SWIG_fail;
7447 }
7448 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7449 return resultobj;
7450 fail:
7451 return NULL;
7452 }
7453
7454
7455 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7456 PyObject *resultobj = 0;
7457 wxRect *arg1 = (wxRect *) 0 ;
7458 wxRect *arg2 = 0 ;
7459 wxRect result;
7460 void *argp1 = 0 ;
7461 int res1 = 0 ;
7462 wxRect temp2 ;
7463 PyObject * obj0 = 0 ;
7464 PyObject * obj1 = 0 ;
7465 char * kwnames[] = {
7466 (char *) "self",(char *) "rect", NULL
7467 };
7468
7469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7471 if (!SWIG_IsOK(res1)) {
7472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7473 }
7474 arg1 = reinterpret_cast< wxRect * >(argp1);
7475 {
7476 arg2 = &temp2;
7477 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7478 }
7479 {
7480 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj = 0;
7492 wxRect *arg1 = (wxRect *) 0 ;
7493 wxRect *arg2 = 0 ;
7494 wxRect *result = 0 ;
7495 void *argp1 = 0 ;
7496 int res1 = 0 ;
7497 wxRect temp2 ;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char * kwnames[] = {
7501 (char *) "self",(char *) "rect", NULL
7502 };
7503
7504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7506 if (!SWIG_IsOK(res1)) {
7507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7508 }
7509 arg1 = reinterpret_cast< wxRect * >(argp1);
7510 {
7511 arg2 = &temp2;
7512 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7513 }
7514 {
7515 {
7516 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7517 result = (wxRect *) &_result_ref;
7518 }
7519 if (PyErr_Occurred()) SWIG_fail;
7520 }
7521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxRect *arg1 = (wxRect *) 0 ;
7531 PyObject *arg2 = (PyObject *) 0 ;
7532 bool result;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 PyObject * obj0 = 0 ;
7536 PyObject * obj1 = 0 ;
7537 char * kwnames[] = {
7538 (char *) "self",(char *) "other", NULL
7539 };
7540
7541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7545 }
7546 arg1 = reinterpret_cast< wxRect * >(argp1);
7547 arg2 = obj1;
7548 {
7549 result = (bool)wxRect___eq__(arg1,arg2);
7550 if (PyErr_Occurred()) SWIG_fail;
7551 }
7552 {
7553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7554 }
7555 return resultobj;
7556 fail:
7557 return NULL;
7558 }
7559
7560
7561 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7562 PyObject *resultobj = 0;
7563 wxRect *arg1 = (wxRect *) 0 ;
7564 PyObject *arg2 = (PyObject *) 0 ;
7565 bool result;
7566 void *argp1 = 0 ;
7567 int res1 = 0 ;
7568 PyObject * obj0 = 0 ;
7569 PyObject * obj1 = 0 ;
7570 char * kwnames[] = {
7571 (char *) "self",(char *) "other", NULL
7572 };
7573
7574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7576 if (!SWIG_IsOK(res1)) {
7577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7578 }
7579 arg1 = reinterpret_cast< wxRect * >(argp1);
7580 arg2 = obj1;
7581 {
7582 result = (bool)wxRect___ne__(arg1,arg2);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 {
7586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7587 }
7588 return resultobj;
7589 fail:
7590 return NULL;
7591 }
7592
7593
7594 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7595 PyObject *resultobj = 0;
7596 wxRect *arg1 = (wxRect *) 0 ;
7597 int arg2 ;
7598 int arg3 ;
7599 bool result;
7600 void *argp1 = 0 ;
7601 int res1 = 0 ;
7602 int val2 ;
7603 int ecode2 = 0 ;
7604 int val3 ;
7605 int ecode3 = 0 ;
7606 PyObject * obj0 = 0 ;
7607 PyObject * obj1 = 0 ;
7608 PyObject * obj2 = 0 ;
7609 char * kwnames[] = {
7610 (char *) "self",(char *) "x",(char *) "y", NULL
7611 };
7612
7613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7615 if (!SWIG_IsOK(res1)) {
7616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7617 }
7618 arg1 = reinterpret_cast< wxRect * >(argp1);
7619 ecode2 = SWIG_AsVal_int(obj1, &val2);
7620 if (!SWIG_IsOK(ecode2)) {
7621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7622 }
7623 arg2 = static_cast< int >(val2);
7624 ecode3 = SWIG_AsVal_int(obj2, &val3);
7625 if (!SWIG_IsOK(ecode3)) {
7626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7627 }
7628 arg3 = static_cast< int >(val3);
7629 {
7630 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7631 if (PyErr_Occurred()) SWIG_fail;
7632 }
7633 {
7634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7635 }
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = 0;
7644 wxRect *arg1 = (wxRect *) 0 ;
7645 wxPoint *arg2 = 0 ;
7646 bool result;
7647 void *argp1 = 0 ;
7648 int res1 = 0 ;
7649 wxPoint temp2 ;
7650 PyObject * obj0 = 0 ;
7651 PyObject * obj1 = 0 ;
7652 char * kwnames[] = {
7653 (char *) "self",(char *) "pt", NULL
7654 };
7655
7656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7660 }
7661 arg1 = reinterpret_cast< wxRect * >(argp1);
7662 {
7663 arg2 = &temp2;
7664 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7665 }
7666 {
7667 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7668 if (PyErr_Occurred()) SWIG_fail;
7669 }
7670 {
7671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7672 }
7673 return resultobj;
7674 fail:
7675 return NULL;
7676 }
7677
7678
7679 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7680 PyObject *resultobj = 0;
7681 wxRect *arg1 = (wxRect *) 0 ;
7682 wxRect *arg2 = 0 ;
7683 bool result;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 wxRect temp2 ;
7687 PyObject * obj0 = 0 ;
7688 PyObject * obj1 = 0 ;
7689 char * kwnames[] = {
7690 (char *) "self",(char *) "rect", NULL
7691 };
7692
7693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",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_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7697 }
7698 arg1 = reinterpret_cast< wxRect * >(argp1);
7699 {
7700 arg2 = &temp2;
7701 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7702 }
7703 {
7704 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7709 }
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7717 PyObject *resultobj = 0;
7718 wxRect *arg1 = (wxRect *) 0 ;
7719 wxRect *arg2 = 0 ;
7720 bool result;
7721 void *argp1 = 0 ;
7722 int res1 = 0 ;
7723 wxRect temp2 ;
7724 PyObject * obj0 = 0 ;
7725 PyObject * obj1 = 0 ;
7726 char * kwnames[] = {
7727 (char *) "self",(char *) "rect", NULL
7728 };
7729
7730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7732 if (!SWIG_IsOK(res1)) {
7733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7734 }
7735 arg1 = reinterpret_cast< wxRect * >(argp1);
7736 {
7737 arg2 = &temp2;
7738 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7739 }
7740 {
7741 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 {
7745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7746 }
7747 return resultobj;
7748 fail:
7749 return NULL;
7750 }
7751
7752
7753 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7754 PyObject *resultobj = 0;
7755 wxRect *arg1 = (wxRect *) 0 ;
7756 wxRect *arg2 = 0 ;
7757 int arg3 = (int) wxBOTH ;
7758 wxRect result;
7759 void *argp1 = 0 ;
7760 int res1 = 0 ;
7761 wxRect temp2 ;
7762 int val3 ;
7763 int ecode3 = 0 ;
7764 PyObject * obj0 = 0 ;
7765 PyObject * obj1 = 0 ;
7766 PyObject * obj2 = 0 ;
7767 char * kwnames[] = {
7768 (char *) "self",(char *) "r",(char *) "dir", NULL
7769 };
7770
7771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 {
7778 arg2 = &temp2;
7779 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7780 }
7781 if (obj2) {
7782 ecode3 = SWIG_AsVal_int(obj2, &val3);
7783 if (!SWIG_IsOK(ecode3)) {
7784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7785 }
7786 arg3 = static_cast< int >(val3);
7787 }
7788 {
7789 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7790 if (PyErr_Occurred()) SWIG_fail;
7791 }
7792 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 int arg2 ;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 int val2 ;
7806 int ecode2 = 0 ;
7807 PyObject *swig_obj[2] ;
7808
7809 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7811 if (!SWIG_IsOK(res1)) {
7812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7813 }
7814 arg1 = reinterpret_cast< wxRect * >(argp1);
7815 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7816 if (!SWIG_IsOK(ecode2)) {
7817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7818 }
7819 arg2 = static_cast< int >(val2);
7820 if (arg1) (arg1)->x = arg2;
7821
7822 resultobj = SWIG_Py_Void();
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830 PyObject *resultobj = 0;
7831 wxRect *arg1 = (wxRect *) 0 ;
7832 int result;
7833 void *argp1 = 0 ;
7834 int res1 = 0 ;
7835 PyObject *swig_obj[1] ;
7836
7837 if (!args) SWIG_fail;
7838 swig_obj[0] = args;
7839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7840 if (!SWIG_IsOK(res1)) {
7841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7842 }
7843 arg1 = reinterpret_cast< wxRect * >(argp1);
7844 result = (int) ((arg1)->x);
7845 resultobj = SWIG_From_int(static_cast< int >(result));
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7853 PyObject *resultobj = 0;
7854 wxRect *arg1 = (wxRect *) 0 ;
7855 int arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 int val2 ;
7859 int ecode2 = 0 ;
7860 PyObject *swig_obj[2] ;
7861
7862 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7864 if (!SWIG_IsOK(res1)) {
7865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7866 }
7867 arg1 = reinterpret_cast< wxRect * >(argp1);
7868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7869 if (!SWIG_IsOK(ecode2)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7871 }
7872 arg2 = static_cast< int >(val2);
7873 if (arg1) (arg1)->y = arg2;
7874
7875 resultobj = SWIG_Py_Void();
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7883 PyObject *resultobj = 0;
7884 wxRect *arg1 = (wxRect *) 0 ;
7885 int result;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 PyObject *swig_obj[1] ;
7889
7890 if (!args) SWIG_fail;
7891 swig_obj[0] = args;
7892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7893 if (!SWIG_IsOK(res1)) {
7894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7895 }
7896 arg1 = reinterpret_cast< wxRect * >(argp1);
7897 result = (int) ((arg1)->y);
7898 resultobj = SWIG_From_int(static_cast< int >(result));
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7906 PyObject *resultobj = 0;
7907 wxRect *arg1 = (wxRect *) 0 ;
7908 int arg2 ;
7909 void *argp1 = 0 ;
7910 int res1 = 0 ;
7911 int val2 ;
7912 int ecode2 = 0 ;
7913 PyObject *swig_obj[2] ;
7914
7915 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7917 if (!SWIG_IsOK(res1)) {
7918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7919 }
7920 arg1 = reinterpret_cast< wxRect * >(argp1);
7921 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7922 if (!SWIG_IsOK(ecode2)) {
7923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7924 }
7925 arg2 = static_cast< int >(val2);
7926 if (arg1) (arg1)->width = arg2;
7927
7928 resultobj = SWIG_Py_Void();
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 PyObject *resultobj = 0;
7937 wxRect *arg1 = (wxRect *) 0 ;
7938 int result;
7939 void *argp1 = 0 ;
7940 int res1 = 0 ;
7941 PyObject *swig_obj[1] ;
7942
7943 if (!args) SWIG_fail;
7944 swig_obj[0] = args;
7945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7948 }
7949 arg1 = reinterpret_cast< wxRect * >(argp1);
7950 result = (int) ((arg1)->width);
7951 resultobj = SWIG_From_int(static_cast< int >(result));
7952 return resultobj;
7953 fail:
7954 return NULL;
7955 }
7956
7957
7958 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7959 PyObject *resultobj = 0;
7960 wxRect *arg1 = (wxRect *) 0 ;
7961 int arg2 ;
7962 void *argp1 = 0 ;
7963 int res1 = 0 ;
7964 int val2 ;
7965 int ecode2 = 0 ;
7966 PyObject *swig_obj[2] ;
7967
7968 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7970 if (!SWIG_IsOK(res1)) {
7971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7972 }
7973 arg1 = reinterpret_cast< wxRect * >(argp1);
7974 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7975 if (!SWIG_IsOK(ecode2)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7977 }
7978 arg2 = static_cast< int >(val2);
7979 if (arg1) (arg1)->height = arg2;
7980
7981 resultobj = SWIG_Py_Void();
7982 return resultobj;
7983 fail:
7984 return NULL;
7985 }
7986
7987
7988 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7989 PyObject *resultobj = 0;
7990 wxRect *arg1 = (wxRect *) 0 ;
7991 int result;
7992 void *argp1 = 0 ;
7993 int res1 = 0 ;
7994 PyObject *swig_obj[1] ;
7995
7996 if (!args) SWIG_fail;
7997 swig_obj[0] = args;
7998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7999 if (!SWIG_IsOK(res1)) {
8000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8001 }
8002 arg1 = reinterpret_cast< wxRect * >(argp1);
8003 result = (int) ((arg1)->height);
8004 resultobj = SWIG_From_int(static_cast< int >(result));
8005 return resultobj;
8006 fail:
8007 return NULL;
8008 }
8009
8010
8011 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8012 PyObject *resultobj = 0;
8013 wxRect *arg1 = (wxRect *) 0 ;
8014 int arg2 = (int) 0 ;
8015 int arg3 = (int) 0 ;
8016 int arg4 = (int) 0 ;
8017 int arg5 = (int) 0 ;
8018 void *argp1 = 0 ;
8019 int res1 = 0 ;
8020 int val2 ;
8021 int ecode2 = 0 ;
8022 int val3 ;
8023 int ecode3 = 0 ;
8024 int val4 ;
8025 int ecode4 = 0 ;
8026 int val5 ;
8027 int ecode5 = 0 ;
8028 PyObject * obj0 = 0 ;
8029 PyObject * obj1 = 0 ;
8030 PyObject * obj2 = 0 ;
8031 PyObject * obj3 = 0 ;
8032 PyObject * obj4 = 0 ;
8033 char * kwnames[] = {
8034 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8035 };
8036
8037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8039 if (!SWIG_IsOK(res1)) {
8040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8041 }
8042 arg1 = reinterpret_cast< wxRect * >(argp1);
8043 if (obj1) {
8044 ecode2 = SWIG_AsVal_int(obj1, &val2);
8045 if (!SWIG_IsOK(ecode2)) {
8046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8047 }
8048 arg2 = static_cast< int >(val2);
8049 }
8050 if (obj2) {
8051 ecode3 = SWIG_AsVal_int(obj2, &val3);
8052 if (!SWIG_IsOK(ecode3)) {
8053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8054 }
8055 arg3 = static_cast< int >(val3);
8056 }
8057 if (obj3) {
8058 ecode4 = SWIG_AsVal_int(obj3, &val4);
8059 if (!SWIG_IsOK(ecode4)) {
8060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8061 }
8062 arg4 = static_cast< int >(val4);
8063 }
8064 if (obj4) {
8065 ecode5 = SWIG_AsVal_int(obj4, &val5);
8066 if (!SWIG_IsOK(ecode5)) {
8067 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8068 }
8069 arg5 = static_cast< int >(val5);
8070 }
8071 {
8072 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8073 if (PyErr_Occurred()) SWIG_fail;
8074 }
8075 resultobj = SWIG_Py_Void();
8076 return resultobj;
8077 fail:
8078 return NULL;
8079 }
8080
8081
8082 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8083 PyObject *resultobj = 0;
8084 wxRect *arg1 = (wxRect *) 0 ;
8085 PyObject *result = 0 ;
8086 void *argp1 = 0 ;
8087 int res1 = 0 ;
8088 PyObject *swig_obj[1] ;
8089
8090 if (!args) SWIG_fail;
8091 swig_obj[0] = args;
8092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8093 if (!SWIG_IsOK(res1)) {
8094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8095 }
8096 arg1 = reinterpret_cast< wxRect * >(argp1);
8097 {
8098 result = (PyObject *)wxRect_Get(arg1);
8099 if (PyErr_Occurred()) SWIG_fail;
8100 }
8101 resultobj = result;
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *obj;
8110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8111 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8112 return SWIG_Py_Void();
8113 }
8114
8115 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8116 return SWIG_Python_InitShadowInstance(args);
8117 }
8118
8119 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj = 0;
8121 wxRect *arg1 = (wxRect *) 0 ;
8122 wxRect *arg2 = (wxRect *) 0 ;
8123 PyObject *result = 0 ;
8124 void *argp1 = 0 ;
8125 int res1 = 0 ;
8126 void *argp2 = 0 ;
8127 int res2 = 0 ;
8128 PyObject * obj0 = 0 ;
8129 PyObject * obj1 = 0 ;
8130 char * kwnames[] = {
8131 (char *) "r1",(char *) "r2", NULL
8132 };
8133
8134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8136 if (!SWIG_IsOK(res1)) {
8137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8138 }
8139 arg1 = reinterpret_cast< wxRect * >(argp1);
8140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8141 if (!SWIG_IsOK(res2)) {
8142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8143 }
8144 arg2 = reinterpret_cast< wxRect * >(argp2);
8145 {
8146 if (!wxPyCheckForApp()) SWIG_fail;
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 result = (PyObject *)wxIntersectRect(arg1,arg2);
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 resultobj = result;
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8160 PyObject *resultobj = 0;
8161 double arg1 = (double) 0.0 ;
8162 double arg2 = (double) 0.0 ;
8163 wxPoint2D *result = 0 ;
8164 double val1 ;
8165 int ecode1 = 0 ;
8166 double val2 ;
8167 int ecode2 = 0 ;
8168 PyObject * obj0 = 0 ;
8169 PyObject * obj1 = 0 ;
8170 char * kwnames[] = {
8171 (char *) "x",(char *) "y", NULL
8172 };
8173
8174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8175 if (obj0) {
8176 ecode1 = SWIG_AsVal_double(obj0, &val1);
8177 if (!SWIG_IsOK(ecode1)) {
8178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8179 }
8180 arg1 = static_cast< double >(val1);
8181 }
8182 if (obj1) {
8183 ecode2 = SWIG_AsVal_double(obj1, &val2);
8184 if (!SWIG_IsOK(ecode2)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8186 }
8187 arg2 = static_cast< double >(val2);
8188 }
8189 {
8190 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 wxPoint2D *arg1 = 0 ;
8203 wxPoint2D *result = 0 ;
8204 wxPoint2D temp1 ;
8205 PyObject * obj0 = 0 ;
8206 char * kwnames[] = {
8207 (char *) "pt", NULL
8208 };
8209
8210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8211 {
8212 arg1 = &temp1;
8213 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8214 }
8215 {
8216 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8217 if (PyErr_Occurred()) SWIG_fail;
8218 }
8219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8220 return resultobj;
8221 fail:
8222 return NULL;
8223 }
8224
8225
8226 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8227 PyObject *resultobj = 0;
8228 wxPoint *arg1 = 0 ;
8229 wxPoint2D *result = 0 ;
8230 wxPoint temp1 ;
8231 PyObject * obj0 = 0 ;
8232 char * kwnames[] = {
8233 (char *) "pt", NULL
8234 };
8235
8236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8237 {
8238 arg1 = &temp1;
8239 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8240 }
8241 {
8242 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8253 PyObject *resultobj = 0;
8254 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 PyObject *swig_obj[1] ;
8258
8259 if (!args) SWIG_fail;
8260 swig_obj[0] = args;
8261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8262 if (!SWIG_IsOK(res1)) {
8263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8264 }
8265 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8266 {
8267 delete arg1;
8268
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_Py_Void();
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8279 PyObject *resultobj = 0;
8280 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8281 int *arg2 = (int *) 0 ;
8282 int *arg3 = (int *) 0 ;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 int temp2 ;
8286 int res2 = SWIG_TMPOBJ ;
8287 int temp3 ;
8288 int res3 = SWIG_TMPOBJ ;
8289 PyObject *swig_obj[1] ;
8290
8291 arg2 = &temp2;
8292 arg3 = &temp3;
8293 if (!args) SWIG_fail;
8294 swig_obj[0] = args;
8295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8296 if (!SWIG_IsOK(res1)) {
8297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8298 }
8299 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8300 {
8301 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 resultobj = SWIG_Py_Void();
8305 if (SWIG_IsTmpObj(res2)) {
8306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8307 } else {
8308 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8310 }
8311 if (SWIG_IsTmpObj(res3)) {
8312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8313 } else {
8314 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8316 }
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8324 PyObject *resultobj = 0;
8325 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8326 int *arg2 = (int *) 0 ;
8327 int *arg3 = (int *) 0 ;
8328 void *argp1 = 0 ;
8329 int res1 = 0 ;
8330 int temp2 ;
8331 int res2 = SWIG_TMPOBJ ;
8332 int temp3 ;
8333 int res3 = SWIG_TMPOBJ ;
8334 PyObject *swig_obj[1] ;
8335
8336 arg2 = &temp2;
8337 arg3 = &temp3;
8338 if (!args) SWIG_fail;
8339 swig_obj[0] = args;
8340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8343 }
8344 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8345 {
8346 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8347 if (PyErr_Occurred()) SWIG_fail;
8348 }
8349 resultobj = SWIG_Py_Void();
8350 if (SWIG_IsTmpObj(res2)) {
8351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8352 } else {
8353 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8355 }
8356 if (SWIG_IsTmpObj(res3)) {
8357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8358 } else {
8359 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8361 }
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 PyObject *resultobj = 0;
8370 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8371 double result;
8372 void *argp1 = 0 ;
8373 int res1 = 0 ;
8374 PyObject *swig_obj[1] ;
8375
8376 if (!args) SWIG_fail;
8377 swig_obj[0] = args;
8378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8379 if (!SWIG_IsOK(res1)) {
8380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8381 }
8382 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8383 {
8384 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8385 if (PyErr_Occurred()) SWIG_fail;
8386 }
8387 resultobj = SWIG_From_double(static_cast< double >(result));
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8395 PyObject *resultobj = 0;
8396 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8397 double result;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 PyObject *swig_obj[1] ;
8401
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_From_double(static_cast< double >(result));
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 double arg2 ;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 double val2 ;
8427 int ecode2 = 0 ;
8428 PyObject * obj0 = 0 ;
8429 PyObject * obj1 = 0 ;
8430 char * kwnames[] = {
8431 (char *) "self",(char *) "length", NULL
8432 };
8433
8434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8436 if (!SWIG_IsOK(res1)) {
8437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8438 }
8439 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8440 ecode2 = SWIG_AsVal_double(obj1, &val2);
8441 if (!SWIG_IsOK(ecode2)) {
8442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8443 }
8444 arg2 = static_cast< double >(val2);
8445 {
8446 (arg1)->SetVectorLength(arg2);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_Py_Void();
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 double arg2 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 double val2 ;
8463 int ecode2 = 0 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "degrees", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 ecode2 = SWIG_AsVal_double(obj1, &val2);
8477 if (!SWIG_IsOK(ecode2)) {
8478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8479 }
8480 arg2 = static_cast< double >(val2);
8481 {
8482 (arg1)->SetVectorAngle(arg2);
8483 if (PyErr_Occurred()) SWIG_fail;
8484 }
8485 resultobj = SWIG_Py_Void();
8486 return resultobj;
8487 fail:
8488 return NULL;
8489 }
8490
8491
8492 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8493 PyObject *resultobj = 0;
8494 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8495 wxPoint2D *arg2 = 0 ;
8496 double result;
8497 void *argp1 = 0 ;
8498 int res1 = 0 ;
8499 wxPoint2D temp2 ;
8500 PyObject * obj0 = 0 ;
8501 PyObject * obj1 = 0 ;
8502 char * kwnames[] = {
8503 (char *) "self",(char *) "pt", NULL
8504 };
8505
8506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8508 if (!SWIG_IsOK(res1)) {
8509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8510 }
8511 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8512 {
8513 arg2 = &temp2;
8514 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8515 }
8516 {
8517 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8518 if (PyErr_Occurred()) SWIG_fail;
8519 }
8520 resultobj = SWIG_From_double(static_cast< double >(result));
8521 return resultobj;
8522 fail:
8523 return NULL;
8524 }
8525
8526
8527 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8528 PyObject *resultobj = 0;
8529 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8530 wxPoint2D *arg2 = 0 ;
8531 double result;
8532 void *argp1 = 0 ;
8533 int res1 = 0 ;
8534 wxPoint2D temp2 ;
8535 PyObject * obj0 = 0 ;
8536 PyObject * obj1 = 0 ;
8537 char * kwnames[] = {
8538 (char *) "self",(char *) "pt", NULL
8539 };
8540
8541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8543 if (!SWIG_IsOK(res1)) {
8544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8545 }
8546 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8547 {
8548 arg2 = &temp2;
8549 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8550 }
8551 {
8552 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 resultobj = SWIG_From_double(static_cast< double >(result));
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj = 0;
8564 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8565 wxPoint2D *arg2 = 0 ;
8566 double result;
8567 void *argp1 = 0 ;
8568 int res1 = 0 ;
8569 wxPoint2D temp2 ;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 char * kwnames[] = {
8573 (char *) "self",(char *) "vec", NULL
8574 };
8575
8576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8580 }
8581 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8582 {
8583 arg2 = &temp2;
8584 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8585 }
8586 {
8587 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 resultobj = SWIG_From_double(static_cast< double >(result));
8591 return resultobj;
8592 fail:
8593 return NULL;
8594 }
8595
8596
8597 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8598 PyObject *resultobj = 0;
8599 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8600 wxPoint2D *arg2 = 0 ;
8601 double result;
8602 void *argp1 = 0 ;
8603 int res1 = 0 ;
8604 wxPoint2D temp2 ;
8605 PyObject * obj0 = 0 ;
8606 PyObject * obj1 = 0 ;
8607 char * kwnames[] = {
8608 (char *) "self",(char *) "vec", NULL
8609 };
8610
8611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8613 if (!SWIG_IsOK(res1)) {
8614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8615 }
8616 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8617 {
8618 arg2 = &temp2;
8619 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8620 }
8621 {
8622 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8623 if (PyErr_Occurred()) SWIG_fail;
8624 }
8625 resultobj = SWIG_From_double(static_cast< double >(result));
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8633 PyObject *resultobj = 0;
8634 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8635 wxPoint2D result;
8636 void *argp1 = 0 ;
8637 int res1 = 0 ;
8638 PyObject *swig_obj[1] ;
8639
8640 if (!args) SWIG_fail;
8641 swig_obj[0] = args;
8642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8643 if (!SWIG_IsOK(res1)) {
8644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8645 }
8646 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8647 {
8648 result = (arg1)->operator -();
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8659 PyObject *resultobj = 0;
8660 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8661 wxPoint2D *arg2 = 0 ;
8662 wxPoint2D *result = 0 ;
8663 void *argp1 = 0 ;
8664 int res1 = 0 ;
8665 wxPoint2D temp2 ;
8666 PyObject * obj0 = 0 ;
8667 PyObject * obj1 = 0 ;
8668 char * kwnames[] = {
8669 (char *) "self",(char *) "pt", NULL
8670 };
8671
8672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8674 if (!SWIG_IsOK(res1)) {
8675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8676 }
8677 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8678 {
8679 arg2 = &temp2;
8680 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8681 }
8682 {
8683 {
8684 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8685 result = (wxPoint2D *) &_result_ref;
8686 }
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 wxPoint2D *arg2 = 0 ;
8700 wxPoint2D *result = 0 ;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 wxPoint2D temp2 ;
8704 PyObject * obj0 = 0 ;
8705 PyObject * obj1 = 0 ;
8706 char * kwnames[] = {
8707 (char *) "self",(char *) "pt", NULL
8708 };
8709
8710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8712 if (!SWIG_IsOK(res1)) {
8713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8714 }
8715 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8716 {
8717 arg2 = &temp2;
8718 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8719 }
8720 {
8721 {
8722 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8723 result = (wxPoint2D *) &_result_ref;
8724 }
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj = 0;
8736 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8737 wxPoint2D *arg2 = 0 ;
8738 wxPoint2D *result = 0 ;
8739 void *argp1 = 0 ;
8740 int res1 = 0 ;
8741 wxPoint2D temp2 ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 char * kwnames[] = {
8745 (char *) "self",(char *) "pt", NULL
8746 };
8747
8748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8750 if (!SWIG_IsOK(res1)) {
8751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8752 }
8753 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8754 {
8755 arg2 = &temp2;
8756 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8757 }
8758 {
8759 {
8760 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8761 result = (wxPoint2D *) &_result_ref;
8762 }
8763 if (PyErr_Occurred()) SWIG_fail;
8764 }
8765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj = 0;
8774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8775 wxPoint2D *arg2 = 0 ;
8776 wxPoint2D *result = 0 ;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 wxPoint2D temp2 ;
8780 PyObject * obj0 = 0 ;
8781 PyObject * obj1 = 0 ;
8782 char * kwnames[] = {
8783 (char *) "self",(char *) "pt", NULL
8784 };
8785
8786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8788 if (!SWIG_IsOK(res1)) {
8789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8790 }
8791 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8792 {
8793 arg2 = &temp2;
8794 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8795 }
8796 {
8797 {
8798 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8799 result = (wxPoint2D *) &_result_ref;
8800 }
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8804 return resultobj;
8805 fail:
8806 return NULL;
8807 }
8808
8809
8810 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj = 0;
8812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8813 PyObject *arg2 = (PyObject *) 0 ;
8814 bool result;
8815 void *argp1 = 0 ;
8816 int res1 = 0 ;
8817 PyObject * obj0 = 0 ;
8818 PyObject * obj1 = 0 ;
8819 char * kwnames[] = {
8820 (char *) "self",(char *) "other", NULL
8821 };
8822
8823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8825 if (!SWIG_IsOK(res1)) {
8826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8827 }
8828 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8829 arg2 = obj1;
8830 {
8831 result = (bool)wxPoint2D___eq__(arg1,arg2);
8832 if (PyErr_Occurred()) SWIG_fail;
8833 }
8834 {
8835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8836 }
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj = 0;
8845 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8846 PyObject *arg2 = (PyObject *) 0 ;
8847 bool result;
8848 void *argp1 = 0 ;
8849 int res1 = 0 ;
8850 PyObject * obj0 = 0 ;
8851 PyObject * obj1 = 0 ;
8852 char * kwnames[] = {
8853 (char *) "self",(char *) "other", NULL
8854 };
8855
8856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8858 if (!SWIG_IsOK(res1)) {
8859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8860 }
8861 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8862 arg2 = obj1;
8863 {
8864 result = (bool)wxPoint2D___ne__(arg1,arg2);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8869 }
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8877 PyObject *resultobj = 0;
8878 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8879 double arg2 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 double val2 ;
8883 int ecode2 = 0 ;
8884 PyObject *swig_obj[2] ;
8885
8886 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8890 }
8891 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8892 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8893 if (!SWIG_IsOK(ecode2)) {
8894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8895 }
8896 arg2 = static_cast< double >(val2);
8897 if (arg1) (arg1)->m_x = arg2;
8898
8899 resultobj = SWIG_Py_Void();
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 double result;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 PyObject *swig_obj[1] ;
8913
8914 if (!args) SWIG_fail;
8915 swig_obj[0] = args;
8916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8917 if (!SWIG_IsOK(res1)) {
8918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8919 }
8920 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8921 result = (double) ((arg1)->m_x);
8922 resultobj = SWIG_From_double(static_cast< double >(result));
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8930 PyObject *resultobj = 0;
8931 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8932 double arg2 ;
8933 void *argp1 = 0 ;
8934 int res1 = 0 ;
8935 double val2 ;
8936 int ecode2 = 0 ;
8937 PyObject *swig_obj[2] ;
8938
8939 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8941 if (!SWIG_IsOK(res1)) {
8942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8943 }
8944 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8945 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8946 if (!SWIG_IsOK(ecode2)) {
8947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8948 }
8949 arg2 = static_cast< double >(val2);
8950 if (arg1) (arg1)->m_y = arg2;
8951
8952 resultobj = SWIG_Py_Void();
8953 return resultobj;
8954 fail:
8955 return NULL;
8956 }
8957
8958
8959 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8960 PyObject *resultobj = 0;
8961 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8962 double result;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8972 }
8973 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8974 result = (double) ((arg1)->m_y);
8975 resultobj = SWIG_From_double(static_cast< double >(result));
8976 return resultobj;
8977 fail:
8978 return NULL;
8979 }
8980
8981
8982 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8983 PyObject *resultobj = 0;
8984 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8985 double arg2 = (double) 0 ;
8986 double arg3 = (double) 0 ;
8987 void *argp1 = 0 ;
8988 int res1 = 0 ;
8989 double val2 ;
8990 int ecode2 = 0 ;
8991 double val3 ;
8992 int ecode3 = 0 ;
8993 PyObject * obj0 = 0 ;
8994 PyObject * obj1 = 0 ;
8995 PyObject * obj2 = 0 ;
8996 char * kwnames[] = {
8997 (char *) "self",(char *) "x",(char *) "y", NULL
8998 };
8999
9000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9002 if (!SWIG_IsOK(res1)) {
9003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9004 }
9005 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9006 if (obj1) {
9007 ecode2 = SWIG_AsVal_double(obj1, &val2);
9008 if (!SWIG_IsOK(ecode2)) {
9009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9010 }
9011 arg2 = static_cast< double >(val2);
9012 }
9013 if (obj2) {
9014 ecode3 = SWIG_AsVal_double(obj2, &val3);
9015 if (!SWIG_IsOK(ecode3)) {
9016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9017 }
9018 arg3 = static_cast< double >(val3);
9019 }
9020 {
9021 wxPoint2D_Set(arg1,arg2,arg3);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 resultobj = SWIG_Py_Void();
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9032 PyObject *resultobj = 0;
9033 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9034 PyObject *result = 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 PyObject *swig_obj[1] ;
9038
9039 if (!args) SWIG_fail;
9040 swig_obj[0] = args;
9041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9044 }
9045 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9046 {
9047 result = (PyObject *)wxPoint2D_Get(arg1);
9048 if (PyErr_Occurred()) SWIG_fail;
9049 }
9050 resultobj = result;
9051 return resultobj;
9052 fail:
9053 return NULL;
9054 }
9055
9056
9057 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9058 PyObject *obj;
9059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9060 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9061 return SWIG_Py_Void();
9062 }
9063
9064 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 return SWIG_Python_InitShadowInstance(args);
9066 }
9067
9068 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9069 PyObject *resultobj = 0;
9070 wxDouble arg1 = (wxDouble) 0.0 ;
9071 wxDouble arg2 = (wxDouble) 0.0 ;
9072 wxDouble arg3 = (wxDouble) 0.0 ;
9073 wxDouble arg4 = (wxDouble) 0.0 ;
9074 wxRect2D *result = 0 ;
9075 void *argp1 ;
9076 int res1 = 0 ;
9077 void *argp2 ;
9078 int res2 = 0 ;
9079 void *argp3 ;
9080 int res3 = 0 ;
9081 void *argp4 ;
9082 int res4 = 0 ;
9083 PyObject * obj0 = 0 ;
9084 PyObject * obj1 = 0 ;
9085 PyObject * obj2 = 0 ;
9086 PyObject * obj3 = 0 ;
9087 char * kwnames[] = {
9088 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9089 };
9090
9091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9092 if (obj0) {
9093 {
9094 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9095 if (!SWIG_IsOK(res1)) {
9096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9097 }
9098 if (!argp1) {
9099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9100 } else {
9101 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9102 arg1 = *temp;
9103 if (SWIG_IsNewObj(res1)) delete temp;
9104 }
9105 }
9106 }
9107 if (obj1) {
9108 {
9109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9110 if (!SWIG_IsOK(res2)) {
9111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9112 }
9113 if (!argp2) {
9114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9115 } else {
9116 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9117 arg2 = *temp;
9118 if (SWIG_IsNewObj(res2)) delete temp;
9119 }
9120 }
9121 }
9122 if (obj2) {
9123 {
9124 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9125 if (!SWIG_IsOK(res3)) {
9126 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9127 }
9128 if (!argp3) {
9129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9130 } else {
9131 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9132 arg3 = *temp;
9133 if (SWIG_IsNewObj(res3)) delete temp;
9134 }
9135 }
9136 }
9137 if (obj3) {
9138 {
9139 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9140 if (!SWIG_IsOK(res4)) {
9141 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9142 }
9143 if (!argp4) {
9144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9145 } else {
9146 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9147 arg4 = *temp;
9148 if (SWIG_IsNewObj(res4)) delete temp;
9149 }
9150 }
9151 }
9152 {
9153 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9154 if (PyErr_Occurred()) SWIG_fail;
9155 }
9156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9157 return resultobj;
9158 fail:
9159 return NULL;
9160 }
9161
9162
9163 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9164 PyObject *resultobj = 0;
9165 wxRect2D *arg1 = (wxRect2D *) 0 ;
9166 void *argp1 = 0 ;
9167 int res1 = 0 ;
9168 PyObject *swig_obj[1] ;
9169
9170 if (!args) SWIG_fail;
9171 swig_obj[0] = args;
9172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9173 if (!SWIG_IsOK(res1)) {
9174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9175 }
9176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9177 {
9178 delete arg1;
9179
9180 if (PyErr_Occurred()) SWIG_fail;
9181 }
9182 resultobj = SWIG_Py_Void();
9183 return resultobj;
9184 fail:
9185 return NULL;
9186 }
9187
9188
9189 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9190 PyObject *resultobj = 0;
9191 wxRect2D *arg1 = (wxRect2D *) 0 ;
9192 wxPoint2D result;
9193 void *argp1 = 0 ;
9194 int res1 = 0 ;
9195 PyObject *swig_obj[1] ;
9196
9197 if (!args) SWIG_fail;
9198 swig_obj[0] = args;
9199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9202 }
9203 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9204 {
9205 result = (arg1)->GetPosition();
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxRect2D *arg1 = (wxRect2D *) 0 ;
9218 wxSize result;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 PyObject *swig_obj[1] ;
9222
9223 if (!args) SWIG_fail;
9224 swig_obj[0] = args;
9225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9226 if (!SWIG_IsOK(res1)) {
9227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9228 }
9229 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9230 {
9231 result = (arg1)->GetSize();
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9242 PyObject *resultobj = 0;
9243 wxRect2D *arg1 = (wxRect2D *) 0 ;
9244 wxDouble result;
9245 void *argp1 = 0 ;
9246 int res1 = 0 ;
9247 PyObject *swig_obj[1] ;
9248
9249 if (!args) SWIG_fail;
9250 swig_obj[0] = args;
9251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9252 if (!SWIG_IsOK(res1)) {
9253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9254 }
9255 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9256 {
9257 result = ((wxRect2D const *)arg1)->GetLeft();
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj = 0;
9269 wxRect2D *arg1 = (wxRect2D *) 0 ;
9270 wxDouble arg2 ;
9271 void *argp1 = 0 ;
9272 int res1 = 0 ;
9273 void *argp2 ;
9274 int res2 = 0 ;
9275 PyObject * obj0 = 0 ;
9276 PyObject * obj1 = 0 ;
9277 char * kwnames[] = {
9278 (char *) "self",(char *) "n", NULL
9279 };
9280
9281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9283 if (!SWIG_IsOK(res1)) {
9284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9285 }
9286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9287 {
9288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9289 if (!SWIG_IsOK(res2)) {
9290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9291 }
9292 if (!argp2) {
9293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9294 } else {
9295 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9296 arg2 = *temp;
9297 if (SWIG_IsNewObj(res2)) delete temp;
9298 }
9299 }
9300 {
9301 (arg1)->SetLeft(arg2);
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_Py_Void();
9305 return resultobj;
9306 fail:
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj = 0;
9313 wxRect2D *arg1 = (wxRect2D *) 0 ;
9314 wxDouble arg2 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 void *argp2 ;
9318 int res2 = 0 ;
9319 PyObject * obj0 = 0 ;
9320 PyObject * obj1 = 0 ;
9321 char * kwnames[] = {
9322 (char *) "self",(char *) "n", NULL
9323 };
9324
9325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9329 }
9330 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9331 {
9332 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9333 if (!SWIG_IsOK(res2)) {
9334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9335 }
9336 if (!argp2) {
9337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9338 } else {
9339 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9340 arg2 = *temp;
9341 if (SWIG_IsNewObj(res2)) delete temp;
9342 }
9343 }
9344 {
9345 (arg1)->MoveLeftTo(arg2);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_Py_Void();
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9356 PyObject *resultobj = 0;
9357 wxRect2D *arg1 = (wxRect2D *) 0 ;
9358 wxDouble result;
9359 void *argp1 = 0 ;
9360 int res1 = 0 ;
9361 PyObject *swig_obj[1] ;
9362
9363 if (!args) SWIG_fail;
9364 swig_obj[0] = args;
9365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9366 if (!SWIG_IsOK(res1)) {
9367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9368 }
9369 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9370 {
9371 result = ((wxRect2D const *)arg1)->GetTop();
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj = 0;
9383 wxRect2D *arg1 = (wxRect2D *) 0 ;
9384 wxDouble arg2 ;
9385 void *argp1 = 0 ;
9386 int res1 = 0 ;
9387 void *argp2 ;
9388 int res2 = 0 ;
9389 PyObject * obj0 = 0 ;
9390 PyObject * obj1 = 0 ;
9391 char * kwnames[] = {
9392 (char *) "self",(char *) "n", NULL
9393 };
9394
9395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9397 if (!SWIG_IsOK(res1)) {
9398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9399 }
9400 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9401 {
9402 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9403 if (!SWIG_IsOK(res2)) {
9404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9405 }
9406 if (!argp2) {
9407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9408 } else {
9409 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9410 arg2 = *temp;
9411 if (SWIG_IsNewObj(res2)) delete temp;
9412 }
9413 }
9414 {
9415 (arg1)->SetTop(arg2);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_Py_Void();
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj = 0;
9427 wxRect2D *arg1 = (wxRect2D *) 0 ;
9428 wxDouble arg2 ;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 void *argp2 ;
9432 int res2 = 0 ;
9433 PyObject * obj0 = 0 ;
9434 PyObject * obj1 = 0 ;
9435 char * kwnames[] = {
9436 (char *) "self",(char *) "n", NULL
9437 };
9438
9439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9441 if (!SWIG_IsOK(res1)) {
9442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9443 }
9444 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9445 {
9446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9447 if (!SWIG_IsOK(res2)) {
9448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9449 }
9450 if (!argp2) {
9451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9452 } else {
9453 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9454 arg2 = *temp;
9455 if (SWIG_IsNewObj(res2)) delete temp;
9456 }
9457 }
9458 {
9459 (arg1)->MoveTopTo(arg2);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 resultobj = SWIG_Py_Void();
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9470 PyObject *resultobj = 0;
9471 wxRect2D *arg1 = (wxRect2D *) 0 ;
9472 wxDouble result;
9473 void *argp1 = 0 ;
9474 int res1 = 0 ;
9475 PyObject *swig_obj[1] ;
9476
9477 if (!args) SWIG_fail;
9478 swig_obj[0] = args;
9479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9480 if (!SWIG_IsOK(res1)) {
9481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9482 }
9483 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9484 {
9485 result = ((wxRect2D const *)arg1)->GetBottom();
9486 if (PyErr_Occurred()) SWIG_fail;
9487 }
9488 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9489 return resultobj;
9490 fail:
9491 return NULL;
9492 }
9493
9494
9495 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj = 0;
9497 wxRect2D *arg1 = (wxRect2D *) 0 ;
9498 wxDouble arg2 ;
9499 void *argp1 = 0 ;
9500 int res1 = 0 ;
9501 void *argp2 ;
9502 int res2 = 0 ;
9503 PyObject * obj0 = 0 ;
9504 PyObject * obj1 = 0 ;
9505 char * kwnames[] = {
9506 (char *) "self",(char *) "n", NULL
9507 };
9508
9509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9511 if (!SWIG_IsOK(res1)) {
9512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9513 }
9514 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9515 {
9516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9517 if (!SWIG_IsOK(res2)) {
9518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9519 }
9520 if (!argp2) {
9521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9522 } else {
9523 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9524 arg2 = *temp;
9525 if (SWIG_IsNewObj(res2)) delete temp;
9526 }
9527 }
9528 {
9529 (arg1)->SetBottom(arg2);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_Py_Void();
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj = 0;
9541 wxRect2D *arg1 = (wxRect2D *) 0 ;
9542 wxDouble arg2 ;
9543 void *argp1 = 0 ;
9544 int res1 = 0 ;
9545 void *argp2 ;
9546 int res2 = 0 ;
9547 PyObject * obj0 = 0 ;
9548 PyObject * obj1 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "n", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9557 }
9558 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9559 {
9560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9561 if (!SWIG_IsOK(res2)) {
9562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9563 }
9564 if (!argp2) {
9565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9566 } else {
9567 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9568 arg2 = *temp;
9569 if (SWIG_IsNewObj(res2)) delete temp;
9570 }
9571 }
9572 {
9573 (arg1)->MoveBottomTo(arg2);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_Py_Void();
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9584 PyObject *resultobj = 0;
9585 wxRect2D *arg1 = (wxRect2D *) 0 ;
9586 wxDouble result;
9587 void *argp1 = 0 ;
9588 int res1 = 0 ;
9589 PyObject *swig_obj[1] ;
9590
9591 if (!args) SWIG_fail;
9592 swig_obj[0] = args;
9593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9594 if (!SWIG_IsOK(res1)) {
9595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9596 }
9597 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9598 {
9599 result = ((wxRect2D const *)arg1)->GetRight();
9600 if (PyErr_Occurred()) SWIG_fail;
9601 }
9602 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9603 return resultobj;
9604 fail:
9605 return NULL;
9606 }
9607
9608
9609 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9610 PyObject *resultobj = 0;
9611 wxRect2D *arg1 = (wxRect2D *) 0 ;
9612 wxDouble arg2 ;
9613 void *argp1 = 0 ;
9614 int res1 = 0 ;
9615 void *argp2 ;
9616 int res2 = 0 ;
9617 PyObject * obj0 = 0 ;
9618 PyObject * obj1 = 0 ;
9619 char * kwnames[] = {
9620 (char *) "self",(char *) "n", NULL
9621 };
9622
9623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9625 if (!SWIG_IsOK(res1)) {
9626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9627 }
9628 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9629 {
9630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9631 if (!SWIG_IsOK(res2)) {
9632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9633 }
9634 if (!argp2) {
9635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9636 } else {
9637 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9638 arg2 = *temp;
9639 if (SWIG_IsNewObj(res2)) delete temp;
9640 }
9641 }
9642 {
9643 (arg1)->SetRight(arg2);
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_Py_Void();
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj = 0;
9655 wxRect2D *arg1 = (wxRect2D *) 0 ;
9656 wxDouble arg2 ;
9657 void *argp1 = 0 ;
9658 int res1 = 0 ;
9659 void *argp2 ;
9660 int res2 = 0 ;
9661 PyObject * obj0 = 0 ;
9662 PyObject * obj1 = 0 ;
9663 char * kwnames[] = {
9664 (char *) "self",(char *) "n", NULL
9665 };
9666
9667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9669 if (!SWIG_IsOK(res1)) {
9670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9671 }
9672 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9673 {
9674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9675 if (!SWIG_IsOK(res2)) {
9676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9677 }
9678 if (!argp2) {
9679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9680 } else {
9681 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9682 arg2 = *temp;
9683 if (SWIG_IsNewObj(res2)) delete temp;
9684 }
9685 }
9686 {
9687 (arg1)->MoveRightTo(arg2);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9698 PyObject *resultobj = 0;
9699 wxRect2D *arg1 = (wxRect2D *) 0 ;
9700 wxPoint2D result;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 PyObject *swig_obj[1] ;
9704
9705 if (!args) SWIG_fail;
9706 swig_obj[0] = args;
9707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9708 if (!SWIG_IsOK(res1)) {
9709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9710 }
9711 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9712 {
9713 result = ((wxRect2D const *)arg1)->GetLeftTop();
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9724 PyObject *resultobj = 0;
9725 wxRect2D *arg1 = (wxRect2D *) 0 ;
9726 wxPoint2D *arg2 = 0 ;
9727 void *argp1 = 0 ;
9728 int res1 = 0 ;
9729 wxPoint2D temp2 ;
9730 PyObject * obj0 = 0 ;
9731 PyObject * obj1 = 0 ;
9732 char * kwnames[] = {
9733 (char *) "self",(char *) "pt", NULL
9734 };
9735
9736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9738 if (!SWIG_IsOK(res1)) {
9739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9740 }
9741 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9742 {
9743 arg2 = &temp2;
9744 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9745 }
9746 {
9747 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9748 if (PyErr_Occurred()) SWIG_fail;
9749 }
9750 resultobj = SWIG_Py_Void();
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj = 0;
9759 wxRect2D *arg1 = (wxRect2D *) 0 ;
9760 wxPoint2D *arg2 = 0 ;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 wxPoint2D temp2 ;
9764 PyObject * obj0 = 0 ;
9765 PyObject * obj1 = 0 ;
9766 char * kwnames[] = {
9767 (char *) "self",(char *) "pt", NULL
9768 };
9769
9770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9774 }
9775 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9776 {
9777 arg2 = &temp2;
9778 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9779 }
9780 {
9781 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9782 if (PyErr_Occurred()) SWIG_fail;
9783 }
9784 resultobj = SWIG_Py_Void();
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792 PyObject *resultobj = 0;
9793 wxRect2D *arg1 = (wxRect2D *) 0 ;
9794 wxPoint2D result;
9795 void *argp1 = 0 ;
9796 int res1 = 0 ;
9797 PyObject *swig_obj[1] ;
9798
9799 if (!args) SWIG_fail;
9800 swig_obj[0] = args;
9801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9804 }
9805 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9806 {
9807 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9818 PyObject *resultobj = 0;
9819 wxRect2D *arg1 = (wxRect2D *) 0 ;
9820 wxPoint2D *arg2 = 0 ;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 wxPoint2D temp2 ;
9824 PyObject * obj0 = 0 ;
9825 PyObject * obj1 = 0 ;
9826 char * kwnames[] = {
9827 (char *) "self",(char *) "pt", NULL
9828 };
9829
9830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9832 if (!SWIG_IsOK(res1)) {
9833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9834 }
9835 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9836 {
9837 arg2 = &temp2;
9838 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9839 }
9840 {
9841 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9842 if (PyErr_Occurred()) SWIG_fail;
9843 }
9844 resultobj = SWIG_Py_Void();
9845 return resultobj;
9846 fail:
9847 return NULL;
9848 }
9849
9850
9851 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9852 PyObject *resultobj = 0;
9853 wxRect2D *arg1 = (wxRect2D *) 0 ;
9854 wxPoint2D *arg2 = 0 ;
9855 void *argp1 = 0 ;
9856 int res1 = 0 ;
9857 wxPoint2D temp2 ;
9858 PyObject * obj0 = 0 ;
9859 PyObject * obj1 = 0 ;
9860 char * kwnames[] = {
9861 (char *) "self",(char *) "pt", NULL
9862 };
9863
9864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9868 }
9869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9870 {
9871 arg2 = &temp2;
9872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9873 }
9874 {
9875 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 resultobj = SWIG_Py_Void();
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9886 PyObject *resultobj = 0;
9887 wxRect2D *arg1 = (wxRect2D *) 0 ;
9888 wxPoint2D result;
9889 void *argp1 = 0 ;
9890 int res1 = 0 ;
9891 PyObject *swig_obj[1] ;
9892
9893 if (!args) SWIG_fail;
9894 swig_obj[0] = args;
9895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9898 }
9899 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9900 {
9901 result = ((wxRect2D const *)arg1)->GetRightTop();
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9905 return resultobj;
9906 fail:
9907 return NULL;
9908 }
9909
9910
9911 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9912 PyObject *resultobj = 0;
9913 wxRect2D *arg1 = (wxRect2D *) 0 ;
9914 wxPoint2D *arg2 = 0 ;
9915 void *argp1 = 0 ;
9916 int res1 = 0 ;
9917 wxPoint2D temp2 ;
9918 PyObject * obj0 = 0 ;
9919 PyObject * obj1 = 0 ;
9920 char * kwnames[] = {
9921 (char *) "self",(char *) "pt", NULL
9922 };
9923
9924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9926 if (!SWIG_IsOK(res1)) {
9927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9928 }
9929 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9930 {
9931 arg2 = &temp2;
9932 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9933 }
9934 {
9935 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_Py_Void();
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj = 0;
9947 wxRect2D *arg1 = (wxRect2D *) 0 ;
9948 wxPoint2D *arg2 = 0 ;
9949 void *argp1 = 0 ;
9950 int res1 = 0 ;
9951 wxPoint2D temp2 ;
9952 PyObject * obj0 = 0 ;
9953 PyObject * obj1 = 0 ;
9954 char * kwnames[] = {
9955 (char *) "self",(char *) "pt", NULL
9956 };
9957
9958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9962 }
9963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9964 {
9965 arg2 = &temp2;
9966 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9967 }
9968 {
9969 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 resultobj = SWIG_Py_Void();
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9980 PyObject *resultobj = 0;
9981 wxRect2D *arg1 = (wxRect2D *) 0 ;
9982 wxPoint2D result;
9983 void *argp1 = 0 ;
9984 int res1 = 0 ;
9985 PyObject *swig_obj[1] ;
9986
9987 if (!args) SWIG_fail;
9988 swig_obj[0] = args;
9989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9992 }
9993 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9994 {
9995 result = ((wxRect2D const *)arg1)->GetRightBottom();
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9999 return resultobj;
10000 fail:
10001 return NULL;
10002 }
10003
10004
10005 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10006 PyObject *resultobj = 0;
10007 wxRect2D *arg1 = (wxRect2D *) 0 ;
10008 wxPoint2D *arg2 = 0 ;
10009 void *argp1 = 0 ;
10010 int res1 = 0 ;
10011 wxPoint2D temp2 ;
10012 PyObject * obj0 = 0 ;
10013 PyObject * obj1 = 0 ;
10014 char * kwnames[] = {
10015 (char *) "self",(char *) "pt", NULL
10016 };
10017
10018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10020 if (!SWIG_IsOK(res1)) {
10021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10022 }
10023 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10024 {
10025 arg2 = &temp2;
10026 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10027 }
10028 {
10029 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10030 if (PyErr_Occurred()) SWIG_fail;
10031 }
10032 resultobj = SWIG_Py_Void();
10033 return resultobj;
10034 fail:
10035 return NULL;
10036 }
10037
10038
10039 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj = 0;
10041 wxRect2D *arg1 = (wxRect2D *) 0 ;
10042 wxPoint2D *arg2 = 0 ;
10043 void *argp1 = 0 ;
10044 int res1 = 0 ;
10045 wxPoint2D temp2 ;
10046 PyObject * obj0 = 0 ;
10047 PyObject * obj1 = 0 ;
10048 char * kwnames[] = {
10049 (char *) "self",(char *) "pt", NULL
10050 };
10051
10052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10056 }
10057 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10058 {
10059 arg2 = &temp2;
10060 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10061 }
10062 {
10063 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10064 if (PyErr_Occurred()) SWIG_fail;
10065 }
10066 resultobj = SWIG_Py_Void();
10067 return resultobj;
10068 fail:
10069 return NULL;
10070 }
10071
10072
10073 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10074 PyObject *resultobj = 0;
10075 wxRect2D *arg1 = (wxRect2D *) 0 ;
10076 wxPoint2D result;
10077 void *argp1 = 0 ;
10078 int res1 = 0 ;
10079 PyObject *swig_obj[1] ;
10080
10081 if (!args) SWIG_fail;
10082 swig_obj[0] = args;
10083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10086 }
10087 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10088 {
10089 result = ((wxRect2D const *)arg1)->GetCentre();
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10093 return resultobj;
10094 fail:
10095 return NULL;
10096 }
10097
10098
10099 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10100 PyObject *resultobj = 0;
10101 wxRect2D *arg1 = (wxRect2D *) 0 ;
10102 wxPoint2D *arg2 = 0 ;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 wxPoint2D temp2 ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char * kwnames[] = {
10109 (char *) "self",(char *) "pt", NULL
10110 };
10111
10112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10116 }
10117 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10118 {
10119 arg2 = &temp2;
10120 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10121 }
10122 {
10123 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 resultobj = SWIG_Py_Void();
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = 0;
10135 wxRect2D *arg1 = (wxRect2D *) 0 ;
10136 wxPoint2D *arg2 = 0 ;
10137 void *argp1 = 0 ;
10138 int res1 = 0 ;
10139 wxPoint2D temp2 ;
10140 PyObject * obj0 = 0 ;
10141 PyObject * obj1 = 0 ;
10142 char * kwnames[] = {
10143 (char *) "self",(char *) "pt", NULL
10144 };
10145
10146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10150 }
10151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10152 {
10153 arg2 = &temp2;
10154 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10155 }
10156 {
10157 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 resultobj = SWIG_Py_Void();
10161 return resultobj;
10162 fail:
10163 return NULL;
10164 }
10165
10166
10167 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10168 PyObject *resultobj = 0;
10169 wxRect2D *arg1 = (wxRect2D *) 0 ;
10170 wxPoint2D *arg2 = 0 ;
10171 wxOutCode result;
10172 void *argp1 = 0 ;
10173 int res1 = 0 ;
10174 wxPoint2D temp2 ;
10175 PyObject * obj0 = 0 ;
10176 PyObject * obj1 = 0 ;
10177 char * kwnames[] = {
10178 (char *) "self",(char *) "pt", NULL
10179 };
10180
10181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10183 if (!SWIG_IsOK(res1)) {
10184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10185 }
10186 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10187 {
10188 arg2 = &temp2;
10189 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10190 }
10191 {
10192 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 resultobj = SWIG_From_int(static_cast< int >(result));
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj = 0;
10204 wxRect2D *arg1 = (wxRect2D *) 0 ;
10205 wxPoint2D *arg2 = 0 ;
10206 bool result;
10207 void *argp1 = 0 ;
10208 int res1 = 0 ;
10209 wxPoint2D temp2 ;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 char * kwnames[] = {
10213 (char *) "self",(char *) "pt", NULL
10214 };
10215
10216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10218 if (!SWIG_IsOK(res1)) {
10219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10220 }
10221 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10222 {
10223 arg2 = &temp2;
10224 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10225 }
10226 {
10227 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10228 if (PyErr_Occurred()) SWIG_fail;
10229 }
10230 {
10231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10232 }
10233 return resultobj;
10234 fail:
10235 return NULL;
10236 }
10237
10238
10239 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10240 PyObject *resultobj = 0;
10241 wxRect2D *arg1 = (wxRect2D *) 0 ;
10242 wxRect2D *arg2 = 0 ;
10243 bool result;
10244 void *argp1 = 0 ;
10245 int res1 = 0 ;
10246 wxRect2D temp2 ;
10247 PyObject * obj0 = 0 ;
10248 PyObject * obj1 = 0 ;
10249 char * kwnames[] = {
10250 (char *) "self",(char *) "rect", NULL
10251 };
10252
10253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10255 if (!SWIG_IsOK(res1)) {
10256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10257 }
10258 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10259 {
10260 arg2 = &temp2;
10261 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10262 }
10263 {
10264 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 {
10268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10269 }
10270 return resultobj;
10271 fail:
10272 return NULL;
10273 }
10274
10275
10276 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10277 PyObject *resultobj = 0;
10278 wxRect2D *arg1 = (wxRect2D *) 0 ;
10279 bool result;
10280 void *argp1 = 0 ;
10281 int res1 = 0 ;
10282 PyObject *swig_obj[1] ;
10283
10284 if (!args) SWIG_fail;
10285 swig_obj[0] = args;
10286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10287 if (!SWIG_IsOK(res1)) {
10288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10289 }
10290 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10291 {
10292 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 {
10296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10297 }
10298 return resultobj;
10299 fail:
10300 return NULL;
10301 }
10302
10303
10304 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10305 PyObject *resultobj = 0;
10306 wxRect2D *arg1 = (wxRect2D *) 0 ;
10307 wxRect2D *arg2 = 0 ;
10308 bool result;
10309 void *argp1 = 0 ;
10310 int res1 = 0 ;
10311 wxRect2D temp2 ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 char * kwnames[] = {
10315 (char *) "self",(char *) "rect", NULL
10316 };
10317
10318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10320 if (!SWIG_IsOK(res1)) {
10321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10322 }
10323 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10324 {
10325 arg2 = &temp2;
10326 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10327 }
10328 {
10329 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 {
10333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10334 }
10335 return resultobj;
10336 fail:
10337 return NULL;
10338 }
10339
10340
10341 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10342 PyObject *resultobj = 0;
10343 wxRect2D *arg1 = (wxRect2D *) 0 ;
10344 wxDouble arg2 ;
10345 wxDouble arg3 ;
10346 void *argp1 = 0 ;
10347 int res1 = 0 ;
10348 void *argp2 ;
10349 int res2 = 0 ;
10350 void *argp3 ;
10351 int res3 = 0 ;
10352
10353 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10355 if (!SWIG_IsOK(res1)) {
10356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10357 }
10358 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10359 {
10360 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10361 if (!SWIG_IsOK(res2)) {
10362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10363 }
10364 if (!argp2) {
10365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10366 } else {
10367 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10368 arg2 = *temp;
10369 if (SWIG_IsNewObj(res2)) delete temp;
10370 }
10371 }
10372 {
10373 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10374 if (!SWIG_IsOK(res3)) {
10375 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10376 }
10377 if (!argp3) {
10378 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10379 } else {
10380 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10381 arg3 = *temp;
10382 if (SWIG_IsNewObj(res3)) delete temp;
10383 }
10384 }
10385 {
10386 (arg1)->Inset(arg2,arg3);
10387 if (PyErr_Occurred()) SWIG_fail;
10388 }
10389 resultobj = SWIG_Py_Void();
10390 return resultobj;
10391 fail:
10392 return NULL;
10393 }
10394
10395
10396 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10397 PyObject *resultobj = 0;
10398 wxRect2D *arg1 = (wxRect2D *) 0 ;
10399 wxDouble arg2 ;
10400 wxDouble arg3 ;
10401 wxDouble arg4 ;
10402 wxDouble arg5 ;
10403 void *argp1 = 0 ;
10404 int res1 = 0 ;
10405 void *argp2 ;
10406 int res2 = 0 ;
10407 void *argp3 ;
10408 int res3 = 0 ;
10409 void *argp4 ;
10410 int res4 = 0 ;
10411 void *argp5 ;
10412 int res5 = 0 ;
10413
10414 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10416 if (!SWIG_IsOK(res1)) {
10417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10418 }
10419 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10420 {
10421 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10422 if (!SWIG_IsOK(res2)) {
10423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10424 }
10425 if (!argp2) {
10426 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10427 } else {
10428 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10429 arg2 = *temp;
10430 if (SWIG_IsNewObj(res2)) delete temp;
10431 }
10432 }
10433 {
10434 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10435 if (!SWIG_IsOK(res3)) {
10436 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10437 }
10438 if (!argp3) {
10439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10440 } else {
10441 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10442 arg3 = *temp;
10443 if (SWIG_IsNewObj(res3)) delete temp;
10444 }
10445 }
10446 {
10447 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10448 if (!SWIG_IsOK(res4)) {
10449 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10450 }
10451 if (!argp4) {
10452 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10453 } else {
10454 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10455 arg4 = *temp;
10456 if (SWIG_IsNewObj(res4)) delete temp;
10457 }
10458 }
10459 {
10460 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10461 if (!SWIG_IsOK(res5)) {
10462 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10463 }
10464 if (!argp5) {
10465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10466 } else {
10467 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10468 arg5 = *temp;
10469 if (SWIG_IsNewObj(res5)) delete temp;
10470 }
10471 }
10472 {
10473 (arg1)->Inset(arg2,arg3,arg4,arg5);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 resultobj = SWIG_Py_Void();
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10484 int argc;
10485 PyObject *argv[6];
10486
10487 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10488 --argc;
10489 if (argc == 3) {
10490 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10491 }
10492 if (argc == 5) {
10493 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10494 }
10495
10496 fail:
10497 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10498 return NULL;
10499 }
10500
10501
10502 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10503 PyObject *resultobj = 0;
10504 wxRect2D *arg1 = (wxRect2D *) 0 ;
10505 wxPoint2D *arg2 = 0 ;
10506 void *argp1 = 0 ;
10507 int res1 = 0 ;
10508 wxPoint2D temp2 ;
10509 PyObject * obj0 = 0 ;
10510 PyObject * obj1 = 0 ;
10511 char * kwnames[] = {
10512 (char *) "self",(char *) "pt", NULL
10513 };
10514
10515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10517 if (!SWIG_IsOK(res1)) {
10518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10519 }
10520 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10521 {
10522 arg2 = &temp2;
10523 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10524 }
10525 {
10526 (arg1)->Offset((wxPoint2D const &)*arg2);
10527 if (PyErr_Occurred()) SWIG_fail;
10528 }
10529 resultobj = SWIG_Py_Void();
10530 return resultobj;
10531 fail:
10532 return NULL;
10533 }
10534
10535
10536 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10537 PyObject *resultobj = 0;
10538 wxRect2D *arg1 = (wxRect2D *) 0 ;
10539 wxRect2D *arg2 = 0 ;
10540 void *argp1 = 0 ;
10541 int res1 = 0 ;
10542 wxRect2D temp2 ;
10543 PyObject * obj0 = 0 ;
10544 PyObject * obj1 = 0 ;
10545 char * kwnames[] = {
10546 (char *) "self",(char *) "rect", NULL
10547 };
10548
10549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10553 }
10554 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10555 {
10556 arg2 = &temp2;
10557 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10558 }
10559 {
10560 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10561 if (PyErr_Occurred()) SWIG_fail;
10562 }
10563 resultobj = SWIG_Py_Void();
10564 return resultobj;
10565 fail:
10566 return NULL;
10567 }
10568
10569
10570 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10571 PyObject *resultobj = 0;
10572 wxRect2D *arg1 = (wxRect2D *) 0 ;
10573 int arg2 ;
10574 int arg3 ;
10575 wxPoint2D result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 int val2 ;
10579 int ecode2 = 0 ;
10580 int val3 ;
10581 int ecode3 = 0 ;
10582 PyObject * obj0 = 0 ;
10583 PyObject * obj1 = 0 ;
10584 PyObject * obj2 = 0 ;
10585 char * kwnames[] = {
10586 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10587 };
10588
10589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10591 if (!SWIG_IsOK(res1)) {
10592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10593 }
10594 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10595 ecode2 = SWIG_AsVal_int(obj1, &val2);
10596 if (!SWIG_IsOK(ecode2)) {
10597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10598 }
10599 arg2 = static_cast< int >(val2);
10600 ecode3 = SWIG_AsVal_int(obj2, &val3);
10601 if (!SWIG_IsOK(ecode3)) {
10602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10603 }
10604 arg3 = static_cast< int >(val3);
10605 {
10606 result = (arg1)->Interpolate(arg2,arg3);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10610 return resultobj;
10611 fail:
10612 return NULL;
10613 }
10614
10615
10616 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10617 PyObject *resultobj = 0;
10618 wxRect2D *arg1 = (wxRect2D *) 0 ;
10619 wxRect2D *arg2 = 0 ;
10620 void *argp1 = 0 ;
10621 int res1 = 0 ;
10622 wxRect2D temp2 ;
10623 PyObject * obj0 = 0 ;
10624 PyObject * obj1 = 0 ;
10625 char * kwnames[] = {
10626 (char *) "self",(char *) "otherRect", NULL
10627 };
10628
10629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10631 if (!SWIG_IsOK(res1)) {
10632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10633 }
10634 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10635 {
10636 arg2 = &temp2;
10637 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10638 }
10639 {
10640 (arg1)->Intersect((wxRect2D const &)*arg2);
10641 if (PyErr_Occurred()) SWIG_fail;
10642 }
10643 resultobj = SWIG_Py_Void();
10644 return resultobj;
10645 fail:
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj = 0;
10652 wxRect2D *arg1 = (wxRect2D *) 0 ;
10653 wxRect2D *arg2 = 0 ;
10654 wxRect2D result;
10655 void *argp1 = 0 ;
10656 int res1 = 0 ;
10657 wxRect2D temp2 ;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 char * kwnames[] = {
10661 (char *) "self",(char *) "otherRect", NULL
10662 };
10663
10664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10666 if (!SWIG_IsOK(res1)) {
10667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10668 }
10669 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10670 {
10671 arg2 = &temp2;
10672 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10673 }
10674 {
10675 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10676 if (PyErr_Occurred()) SWIG_fail;
10677 }
10678 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10679 return resultobj;
10680 fail:
10681 return NULL;
10682 }
10683
10684
10685 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj = 0;
10687 wxRect2D *arg1 = (wxRect2D *) 0 ;
10688 wxRect2D *arg2 = 0 ;
10689 bool result;
10690 void *argp1 = 0 ;
10691 int res1 = 0 ;
10692 wxRect2D temp2 ;
10693 PyObject * obj0 = 0 ;
10694 PyObject * obj1 = 0 ;
10695 char * kwnames[] = {
10696 (char *) "self",(char *) "rect", NULL
10697 };
10698
10699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10701 if (!SWIG_IsOK(res1)) {
10702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10703 }
10704 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10705 {
10706 arg2 = &temp2;
10707 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10708 }
10709 {
10710 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 {
10714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10715 }
10716 return resultobj;
10717 fail:
10718 return NULL;
10719 }
10720
10721
10722 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10723 PyObject *resultobj = 0;
10724 wxRect2D *arg1 = (wxRect2D *) 0 ;
10725 wxRect2D *arg2 = 0 ;
10726 void *argp1 = 0 ;
10727 int res1 = 0 ;
10728 wxRect2D temp2 ;
10729 PyObject * obj0 = 0 ;
10730 PyObject * obj1 = 0 ;
10731 char * kwnames[] = {
10732 (char *) "self",(char *) "otherRect", NULL
10733 };
10734
10735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10737 if (!SWIG_IsOK(res1)) {
10738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10739 }
10740 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10741 {
10742 arg2 = &temp2;
10743 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10744 }
10745 {
10746 (arg1)->Union((wxRect2D const &)*arg2);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 resultobj = SWIG_Py_Void();
10750 return resultobj;
10751 fail:
10752 return NULL;
10753 }
10754
10755
10756 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10757 PyObject *resultobj = 0;
10758 wxRect2D *arg1 = (wxRect2D *) 0 ;
10759 wxRect2D *arg2 = 0 ;
10760 wxRect2D result;
10761 void *argp1 = 0 ;
10762 int res1 = 0 ;
10763 wxRect2D temp2 ;
10764 PyObject * obj0 = 0 ;
10765 PyObject * obj1 = 0 ;
10766 char * kwnames[] = {
10767 (char *) "self",(char *) "otherRect", NULL
10768 };
10769
10770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10772 if (!SWIG_IsOK(res1)) {
10773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10774 }
10775 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10776 {
10777 arg2 = &temp2;
10778 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10779 }
10780 {
10781 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10792 PyObject *resultobj = 0;
10793 wxRect2D *arg1 = (wxRect2D *) 0 ;
10794 wxDouble arg2 ;
10795 void *argp1 = 0 ;
10796 int res1 = 0 ;
10797 void *argp2 ;
10798 int res2 = 0 ;
10799
10800 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10802 if (!SWIG_IsOK(res1)) {
10803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10804 }
10805 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10806 {
10807 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10808 if (!SWIG_IsOK(res2)) {
10809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10810 }
10811 if (!argp2) {
10812 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10813 } else {
10814 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10815 arg2 = *temp;
10816 if (SWIG_IsNewObj(res2)) delete temp;
10817 }
10818 }
10819 {
10820 (arg1)->Scale(arg2);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_Py_Void();
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10831 PyObject *resultobj = 0;
10832 wxRect2D *arg1 = (wxRect2D *) 0 ;
10833 int arg2 ;
10834 int arg3 ;
10835 void *argp1 = 0 ;
10836 int res1 = 0 ;
10837 int val2 ;
10838 int ecode2 = 0 ;
10839 int val3 ;
10840 int ecode3 = 0 ;
10841
10842 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10844 if (!SWIG_IsOK(res1)) {
10845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10846 }
10847 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10848 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10849 if (!SWIG_IsOK(ecode2)) {
10850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10851 }
10852 arg2 = static_cast< int >(val2);
10853 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10854 if (!SWIG_IsOK(ecode3)) {
10855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10856 }
10857 arg3 = static_cast< int >(val3);
10858 {
10859 (arg1)->Scale(arg2,arg3);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 resultobj = SWIG_Py_Void();
10863 return resultobj;
10864 fail:
10865 return NULL;
10866 }
10867
10868
10869 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10870 int argc;
10871 PyObject *argv[4];
10872
10873 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10874 --argc;
10875 if (argc == 2) {
10876 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10877 }
10878 if (argc == 3) {
10879 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10880 }
10881
10882 fail:
10883 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj = 0;
10890 wxRect2D *arg1 = (wxRect2D *) 0 ;
10891 PyObject *arg2 = (PyObject *) 0 ;
10892 bool result;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 PyObject * obj0 = 0 ;
10896 PyObject * obj1 = 0 ;
10897 char * kwnames[] = {
10898 (char *) "self",(char *) "other", NULL
10899 };
10900
10901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10903 if (!SWIG_IsOK(res1)) {
10904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10905 }
10906 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10907 arg2 = obj1;
10908 {
10909 result = (bool)wxRect2D___eq__(arg1,arg2);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10914 }
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj = 0;
10923 wxRect2D *arg1 = (wxRect2D *) 0 ;
10924 PyObject *arg2 = (PyObject *) 0 ;
10925 bool result;
10926 void *argp1 = 0 ;
10927 int res1 = 0 ;
10928 PyObject * obj0 = 0 ;
10929 PyObject * obj1 = 0 ;
10930 char * kwnames[] = {
10931 (char *) "self",(char *) "other", NULL
10932 };
10933
10934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10936 if (!SWIG_IsOK(res1)) {
10937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10938 }
10939 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10940 arg2 = obj1;
10941 {
10942 result = (bool)wxRect2D___ne__(arg1,arg2);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 {
10946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10947 }
10948 return resultobj;
10949 fail:
10950 return NULL;
10951 }
10952
10953
10954 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10955 PyObject *resultobj = 0;
10956 wxRect2D *arg1 = (wxRect2D *) 0 ;
10957 wxDouble arg2 ;
10958 void *argp1 = 0 ;
10959 int res1 = 0 ;
10960 void *argp2 ;
10961 int res2 = 0 ;
10962 PyObject *swig_obj[2] ;
10963
10964 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
10968 }
10969 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10970 {
10971 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10972 if (!SWIG_IsOK(res2)) {
10973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
10974 }
10975 if (!argp2) {
10976 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
10977 } else {
10978 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10979 arg2 = *temp;
10980 if (SWIG_IsNewObj(res2)) delete temp;
10981 }
10982 }
10983 if (arg1) (arg1)->m_x = arg2;
10984
10985 resultobj = SWIG_Py_Void();
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10993 PyObject *resultobj = 0;
10994 wxRect2D *arg1 = (wxRect2D *) 0 ;
10995 wxDouble result;
10996 void *argp1 = 0 ;
10997 int res1 = 0 ;
10998 PyObject *swig_obj[1] ;
10999
11000 if (!args) SWIG_fail;
11001 swig_obj[0] = args;
11002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11003 if (!SWIG_IsOK(res1)) {
11004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11005 }
11006 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11007 result = ((arg1)->m_x);
11008 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11016 PyObject *resultobj = 0;
11017 wxRect2D *arg1 = (wxRect2D *) 0 ;
11018 wxDouble arg2 ;
11019 void *argp1 = 0 ;
11020 int res1 = 0 ;
11021 void *argp2 ;
11022 int res2 = 0 ;
11023 PyObject *swig_obj[2] ;
11024
11025 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11027 if (!SWIG_IsOK(res1)) {
11028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11029 }
11030 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11031 {
11032 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11033 if (!SWIG_IsOK(res2)) {
11034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11035 }
11036 if (!argp2) {
11037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11038 } else {
11039 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11040 arg2 = *temp;
11041 if (SWIG_IsNewObj(res2)) delete temp;
11042 }
11043 }
11044 if (arg1) (arg1)->m_y = arg2;
11045
11046 resultobj = SWIG_Py_Void();
11047 return resultobj;
11048 fail:
11049 return NULL;
11050 }
11051
11052
11053 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11054 PyObject *resultobj = 0;
11055 wxRect2D *arg1 = (wxRect2D *) 0 ;
11056 wxDouble result;
11057 void *argp1 = 0 ;
11058 int res1 = 0 ;
11059 PyObject *swig_obj[1] ;
11060
11061 if (!args) SWIG_fail;
11062 swig_obj[0] = args;
11063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11066 }
11067 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11068 result = ((arg1)->m_y);
11069 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11077 PyObject *resultobj = 0;
11078 wxRect2D *arg1 = (wxRect2D *) 0 ;
11079 wxDouble arg2 ;
11080 void *argp1 = 0 ;
11081 int res1 = 0 ;
11082 void *argp2 ;
11083 int res2 = 0 ;
11084 PyObject *swig_obj[2] ;
11085
11086 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11088 if (!SWIG_IsOK(res1)) {
11089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11090 }
11091 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11092 {
11093 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11094 if (!SWIG_IsOK(res2)) {
11095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11096 }
11097 if (!argp2) {
11098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11099 } else {
11100 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11101 arg2 = *temp;
11102 if (SWIG_IsNewObj(res2)) delete temp;
11103 }
11104 }
11105 if (arg1) (arg1)->m_width = arg2;
11106
11107 resultobj = SWIG_Py_Void();
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11115 PyObject *resultobj = 0;
11116 wxRect2D *arg1 = (wxRect2D *) 0 ;
11117 wxDouble result;
11118 void *argp1 = 0 ;
11119 int res1 = 0 ;
11120 PyObject *swig_obj[1] ;
11121
11122 if (!args) SWIG_fail;
11123 swig_obj[0] = args;
11124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11125 if (!SWIG_IsOK(res1)) {
11126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11127 }
11128 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11129 result = ((arg1)->m_width);
11130 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11138 PyObject *resultobj = 0;
11139 wxRect2D *arg1 = (wxRect2D *) 0 ;
11140 wxDouble arg2 ;
11141 void *argp1 = 0 ;
11142 int res1 = 0 ;
11143 void *argp2 ;
11144 int res2 = 0 ;
11145 PyObject *swig_obj[2] ;
11146
11147 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11149 if (!SWIG_IsOK(res1)) {
11150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11151 }
11152 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11153 {
11154 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11155 if (!SWIG_IsOK(res2)) {
11156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11157 }
11158 if (!argp2) {
11159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11160 } else {
11161 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11162 arg2 = *temp;
11163 if (SWIG_IsNewObj(res2)) delete temp;
11164 }
11165 }
11166 if (arg1) (arg1)->m_height = arg2;
11167
11168 resultobj = SWIG_Py_Void();
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11176 PyObject *resultobj = 0;
11177 wxRect2D *arg1 = (wxRect2D *) 0 ;
11178 wxDouble result;
11179 void *argp1 = 0 ;
11180 int res1 = 0 ;
11181 PyObject *swig_obj[1] ;
11182
11183 if (!args) SWIG_fail;
11184 swig_obj[0] = args;
11185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11186 if (!SWIG_IsOK(res1)) {
11187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11188 }
11189 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11190 result = ((arg1)->m_height);
11191 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11199 PyObject *resultobj = 0;
11200 wxRect2D *arg1 = (wxRect2D *) 0 ;
11201 wxDouble arg2 = (wxDouble) 0 ;
11202 wxDouble arg3 = (wxDouble) 0 ;
11203 wxDouble arg4 = (wxDouble) 0 ;
11204 wxDouble arg5 = (wxDouble) 0 ;
11205 void *argp1 = 0 ;
11206 int res1 = 0 ;
11207 void *argp2 ;
11208 int res2 = 0 ;
11209 void *argp3 ;
11210 int res3 = 0 ;
11211 void *argp4 ;
11212 int res4 = 0 ;
11213 void *argp5 ;
11214 int res5 = 0 ;
11215 PyObject * obj0 = 0 ;
11216 PyObject * obj1 = 0 ;
11217 PyObject * obj2 = 0 ;
11218 PyObject * obj3 = 0 ;
11219 PyObject * obj4 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11226 if (!SWIG_IsOK(res1)) {
11227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11228 }
11229 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11230 if (obj1) {
11231 {
11232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11233 if (!SWIG_IsOK(res2)) {
11234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11235 }
11236 if (!argp2) {
11237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11238 } else {
11239 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11240 arg2 = *temp;
11241 if (SWIG_IsNewObj(res2)) delete temp;
11242 }
11243 }
11244 }
11245 if (obj2) {
11246 {
11247 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11248 if (!SWIG_IsOK(res3)) {
11249 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11250 }
11251 if (!argp3) {
11252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11253 } else {
11254 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11255 arg3 = *temp;
11256 if (SWIG_IsNewObj(res3)) delete temp;
11257 }
11258 }
11259 }
11260 if (obj3) {
11261 {
11262 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11263 if (!SWIG_IsOK(res4)) {
11264 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11265 }
11266 if (!argp4) {
11267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11268 } else {
11269 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11270 arg4 = *temp;
11271 if (SWIG_IsNewObj(res4)) delete temp;
11272 }
11273 }
11274 }
11275 if (obj4) {
11276 {
11277 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11278 if (!SWIG_IsOK(res5)) {
11279 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11280 }
11281 if (!argp5) {
11282 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11283 } else {
11284 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11285 arg5 = *temp;
11286 if (SWIG_IsNewObj(res5)) delete temp;
11287 }
11288 }
11289 }
11290 {
11291 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11292 if (PyErr_Occurred()) SWIG_fail;
11293 }
11294 resultobj = SWIG_Py_Void();
11295 return resultobj;
11296 fail:
11297 return NULL;
11298 }
11299
11300
11301 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11302 PyObject *resultobj = 0;
11303 wxRect2D *arg1 = (wxRect2D *) 0 ;
11304 PyObject *result = 0 ;
11305 void *argp1 = 0 ;
11306 int res1 = 0 ;
11307 PyObject *swig_obj[1] ;
11308
11309 if (!args) SWIG_fail;
11310 swig_obj[0] = args;
11311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11312 if (!SWIG_IsOK(res1)) {
11313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11314 }
11315 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11316 {
11317 result = (PyObject *)wxRect2D_Get(arg1);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 resultobj = result;
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11328 PyObject *obj;
11329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11330 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11331 return SWIG_Py_Void();
11332 }
11333
11334 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11335 return SWIG_Python_InitShadowInstance(args);
11336 }
11337
11338 SWIGINTERN int DefaultPosition_set(PyObject *) {
11339 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11340 return 1;
11341 }
11342
11343
11344 SWIGINTERN PyObject *DefaultPosition_get(void) {
11345 PyObject *pyobj = 0;
11346
11347 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11348 return pyobj;
11349 }
11350
11351
11352 SWIGINTERN int DefaultSize_set(PyObject *) {
11353 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11354 return 1;
11355 }
11356
11357
11358 SWIGINTERN PyObject *DefaultSize_get(void) {
11359 PyObject *pyobj = 0;
11360
11361 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11362 return pyobj;
11363 }
11364
11365
11366 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj = 0;
11368 PyObject *arg1 = (PyObject *) 0 ;
11369 wxPyInputStream *result = 0 ;
11370 PyObject * obj0 = 0 ;
11371 char * kwnames[] = {
11372 (char *) "p", NULL
11373 };
11374
11375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11376 arg1 = obj0;
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11380 wxPyEndAllowThreads(__tstate);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11391 PyObject *resultobj = 0;
11392 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11393 void *argp1 = 0 ;
11394 int res1 = 0 ;
11395 PyObject *swig_obj[1] ;
11396
11397 if (!args) SWIG_fail;
11398 swig_obj[0] = args;
11399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11400 if (!SWIG_IsOK(res1)) {
11401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11402 }
11403 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11404 {
11405 PyThreadState* __tstate = wxPyBeginAllowThreads();
11406 delete arg1;
11407
11408 wxPyEndAllowThreads(__tstate);
11409 if (PyErr_Occurred()) SWIG_fail;
11410 }
11411 resultobj = SWIG_Py_Void();
11412 return resultobj;
11413 fail:
11414 return NULL;
11415 }
11416
11417
11418 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11419 PyObject *resultobj = 0;
11420 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11421 void *argp1 = 0 ;
11422 int res1 = 0 ;
11423 PyObject *swig_obj[1] ;
11424
11425 if (!args) SWIG_fail;
11426 swig_obj[0] = args;
11427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11428 if (!SWIG_IsOK(res1)) {
11429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11430 }
11431 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11432 {
11433 PyThreadState* __tstate = wxPyBeginAllowThreads();
11434 (arg1)->close();
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 resultobj = SWIG_Py_Void();
11439 return resultobj;
11440 fail:
11441 return NULL;
11442 }
11443
11444
11445 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11446 PyObject *resultobj = 0;
11447 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11448 void *argp1 = 0 ;
11449 int res1 = 0 ;
11450 PyObject *swig_obj[1] ;
11451
11452 if (!args) SWIG_fail;
11453 swig_obj[0] = args;
11454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11455 if (!SWIG_IsOK(res1)) {
11456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11457 }
11458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11459 {
11460 PyThreadState* __tstate = wxPyBeginAllowThreads();
11461 (arg1)->flush();
11462 wxPyEndAllowThreads(__tstate);
11463 if (PyErr_Occurred()) SWIG_fail;
11464 }
11465 resultobj = SWIG_Py_Void();
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11473 PyObject *resultobj = 0;
11474 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11475 bool result;
11476 void *argp1 = 0 ;
11477 int res1 = 0 ;
11478 PyObject *swig_obj[1] ;
11479
11480 if (!args) SWIG_fail;
11481 swig_obj[0] = args;
11482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11483 if (!SWIG_IsOK(res1)) {
11484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11485 }
11486 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11487 {
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 result = (bool)(arg1)->eof();
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 {
11494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11495 }
11496 return resultobj;
11497 fail:
11498 return NULL;
11499 }
11500
11501
11502 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11503 PyObject *resultobj = 0;
11504 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11505 int arg2 = (int) -1 ;
11506 PyObject *result = 0 ;
11507 void *argp1 = 0 ;
11508 int res1 = 0 ;
11509 int val2 ;
11510 int ecode2 = 0 ;
11511 PyObject * obj0 = 0 ;
11512 PyObject * obj1 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "self",(char *) "size", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11523 if (obj1) {
11524 ecode2 = SWIG_AsVal_int(obj1, &val2);
11525 if (!SWIG_IsOK(ecode2)) {
11526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11527 }
11528 arg2 = static_cast< int >(val2);
11529 }
11530 {
11531 PyThreadState* __tstate = wxPyBeginAllowThreads();
11532 result = (PyObject *)(arg1)->read(arg2);
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 resultobj = result;
11537 return resultobj;
11538 fail:
11539 return NULL;
11540 }
11541
11542
11543 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11544 PyObject *resultobj = 0;
11545 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11546 int arg2 = (int) -1 ;
11547 PyObject *result = 0 ;
11548 void *argp1 = 0 ;
11549 int res1 = 0 ;
11550 int val2 ;
11551 int ecode2 = 0 ;
11552 PyObject * obj0 = 0 ;
11553 PyObject * obj1 = 0 ;
11554 char * kwnames[] = {
11555 (char *) "self",(char *) "size", NULL
11556 };
11557
11558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11560 if (!SWIG_IsOK(res1)) {
11561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11562 }
11563 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11564 if (obj1) {
11565 ecode2 = SWIG_AsVal_int(obj1, &val2);
11566 if (!SWIG_IsOK(ecode2)) {
11567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11568 }
11569 arg2 = static_cast< int >(val2);
11570 }
11571 {
11572 PyThreadState* __tstate = wxPyBeginAllowThreads();
11573 result = (PyObject *)(arg1)->readline(arg2);
11574 wxPyEndAllowThreads(__tstate);
11575 if (PyErr_Occurred()) SWIG_fail;
11576 }
11577 resultobj = result;
11578 return resultobj;
11579 fail:
11580 return NULL;
11581 }
11582
11583
11584 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11585 PyObject *resultobj = 0;
11586 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11587 int arg2 = (int) -1 ;
11588 PyObject *result = 0 ;
11589 void *argp1 = 0 ;
11590 int res1 = 0 ;
11591 int val2 ;
11592 int ecode2 = 0 ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 char * kwnames[] = {
11596 (char *) "self",(char *) "sizehint", NULL
11597 };
11598
11599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11601 if (!SWIG_IsOK(res1)) {
11602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11603 }
11604 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11605 if (obj1) {
11606 ecode2 = SWIG_AsVal_int(obj1, &val2);
11607 if (!SWIG_IsOK(ecode2)) {
11608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11609 }
11610 arg2 = static_cast< int >(val2);
11611 }
11612 {
11613 PyThreadState* __tstate = wxPyBeginAllowThreads();
11614 result = (PyObject *)(arg1)->readlines(arg2);
11615 wxPyEndAllowThreads(__tstate);
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = result;
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj = 0;
11627 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11628 int arg2 ;
11629 int arg3 = (int) 0 ;
11630 void *argp1 = 0 ;
11631 int res1 = 0 ;
11632 int val2 ;
11633 int ecode2 = 0 ;
11634 int val3 ;
11635 int ecode3 = 0 ;
11636 PyObject * obj0 = 0 ;
11637 PyObject * obj1 = 0 ;
11638 PyObject * obj2 = 0 ;
11639 char * kwnames[] = {
11640 (char *) "self",(char *) "offset",(char *) "whence", NULL
11641 };
11642
11643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11645 if (!SWIG_IsOK(res1)) {
11646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11647 }
11648 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11649 ecode2 = SWIG_AsVal_int(obj1, &val2);
11650 if (!SWIG_IsOK(ecode2)) {
11651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11652 }
11653 arg2 = static_cast< int >(val2);
11654 if (obj2) {
11655 ecode3 = SWIG_AsVal_int(obj2, &val3);
11656 if (!SWIG_IsOK(ecode3)) {
11657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11658 }
11659 arg3 = static_cast< int >(val3);
11660 }
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 (arg1)->seek(arg2,arg3);
11664 wxPyEndAllowThreads(__tstate);
11665 if (PyErr_Occurred()) SWIG_fail;
11666 }
11667 resultobj = SWIG_Py_Void();
11668 return resultobj;
11669 fail:
11670 return NULL;
11671 }
11672
11673
11674 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11675 PyObject *resultobj = 0;
11676 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11677 int result;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 PyObject *swig_obj[1] ;
11681
11682 if (!args) SWIG_fail;
11683 swig_obj[0] = args;
11684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11685 if (!SWIG_IsOK(res1)) {
11686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11687 }
11688 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = (int)(arg1)->tell();
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 resultobj = SWIG_From_int(static_cast< int >(result));
11696 return resultobj;
11697 fail:
11698 return NULL;
11699 }
11700
11701
11702 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11703 PyObject *resultobj = 0;
11704 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11705 char result;
11706 void *argp1 = 0 ;
11707 int res1 = 0 ;
11708 PyObject *swig_obj[1] ;
11709
11710 if (!args) SWIG_fail;
11711 swig_obj[0] = args;
11712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11713 if (!SWIG_IsOK(res1)) {
11714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11715 }
11716 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (char)(arg1)->Peek();
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 resultobj = SWIG_From_char(static_cast< char >(result));
11724 return resultobj;
11725 fail:
11726 return NULL;
11727 }
11728
11729
11730 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11731 PyObject *resultobj = 0;
11732 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11733 char result;
11734 void *argp1 = 0 ;
11735 int res1 = 0 ;
11736 PyObject *swig_obj[1] ;
11737
11738 if (!args) SWIG_fail;
11739 swig_obj[0] = args;
11740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11741 if (!SWIG_IsOK(res1)) {
11742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11743 }
11744 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 result = (char)(arg1)->GetC();
11748 wxPyEndAllowThreads(__tstate);
11749 if (PyErr_Occurred()) SWIG_fail;
11750 }
11751 resultobj = SWIG_From_char(static_cast< char >(result));
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11759 PyObject *resultobj = 0;
11760 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11761 size_t result;
11762 void *argp1 = 0 ;
11763 int res1 = 0 ;
11764 PyObject *swig_obj[1] ;
11765
11766 if (!args) SWIG_fail;
11767 swig_obj[0] = args;
11768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11769 if (!SWIG_IsOK(res1)) {
11770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11771 }
11772 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (size_t)(arg1)->LastRead();
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *resultobj = 0;
11788 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11789 bool result;
11790 void *argp1 = 0 ;
11791 int res1 = 0 ;
11792 PyObject *swig_obj[1] ;
11793
11794 if (!args) SWIG_fail;
11795 swig_obj[0] = args;
11796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11799 }
11800 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (bool)(arg1)->CanRead();
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11809 }
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11817 PyObject *resultobj = 0;
11818 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11819 bool result;
11820 void *argp1 = 0 ;
11821 int res1 = 0 ;
11822 PyObject *swig_obj[1] ;
11823
11824 if (!args) SWIG_fail;
11825 swig_obj[0] = args;
11826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11827 if (!SWIG_IsOK(res1)) {
11828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11829 }
11830 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11831 {
11832 PyThreadState* __tstate = wxPyBeginAllowThreads();
11833 result = (bool)(arg1)->Eof();
11834 wxPyEndAllowThreads(__tstate);
11835 if (PyErr_Occurred()) SWIG_fail;
11836 }
11837 {
11838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11839 }
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11847 PyObject *resultobj = 0;
11848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11849 char arg2 ;
11850 bool result;
11851 void *argp1 = 0 ;
11852 int res1 = 0 ;
11853 char val2 ;
11854 int ecode2 = 0 ;
11855 PyObject * obj0 = 0 ;
11856 PyObject * obj1 = 0 ;
11857 char * kwnames[] = {
11858 (char *) "self",(char *) "c", NULL
11859 };
11860
11861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11863 if (!SWIG_IsOK(res1)) {
11864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11865 }
11866 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11867 ecode2 = SWIG_AsVal_char(obj1, &val2);
11868 if (!SWIG_IsOK(ecode2)) {
11869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11870 }
11871 arg2 = static_cast< char >(val2);
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (bool)(arg1)->Ungetch(arg2);
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj = 0;
11889 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11890 long arg2 ;
11891 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11892 long result;
11893 void *argp1 = 0 ;
11894 int res1 = 0 ;
11895 long val2 ;
11896 int ecode2 = 0 ;
11897 int val3 ;
11898 int ecode3 = 0 ;
11899 PyObject * obj0 = 0 ;
11900 PyObject * obj1 = 0 ;
11901 PyObject * obj2 = 0 ;
11902 char * kwnames[] = {
11903 (char *) "self",(char *) "pos",(char *) "mode", NULL
11904 };
11905
11906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11908 if (!SWIG_IsOK(res1)) {
11909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11910 }
11911 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11912 ecode2 = SWIG_AsVal_long(obj1, &val2);
11913 if (!SWIG_IsOK(ecode2)) {
11914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11915 }
11916 arg2 = static_cast< long >(val2);
11917 if (obj2) {
11918 ecode3 = SWIG_AsVal_int(obj2, &val3);
11919 if (!SWIG_IsOK(ecode3)) {
11920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11921 }
11922 arg3 = static_cast< wxSeekMode >(val3);
11923 }
11924 {
11925 PyThreadState* __tstate = wxPyBeginAllowThreads();
11926 result = (long)(arg1)->SeekI(arg2,arg3);
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 resultobj = SWIG_From_long(static_cast< long >(result));
11931 return resultobj;
11932 fail:
11933 return NULL;
11934 }
11935
11936
11937 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11938 PyObject *resultobj = 0;
11939 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11940 long result;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 PyObject *swig_obj[1] ;
11944
11945 if (!args) SWIG_fail;
11946 swig_obj[0] = args;
11947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11948 if (!SWIG_IsOK(res1)) {
11949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11950 }
11951 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (long)(arg1)->TellI();
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 resultobj = SWIG_From_long(static_cast< long >(result));
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11966 PyObject *obj;
11967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11968 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
11969 return SWIG_Py_Void();
11970 }
11971
11972 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11973 return SWIG_Python_InitShadowInstance(args);
11974 }
11975
11976 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11977 PyObject *resultobj = 0;
11978 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
11979 PyObject *arg2 = (PyObject *) 0 ;
11980 void *argp1 = 0 ;
11981 int res1 = 0 ;
11982 PyObject * obj0 = 0 ;
11983 PyObject * obj1 = 0 ;
11984 char * kwnames[] = {
11985 (char *) "self",(char *) "obj", NULL
11986 };
11987
11988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
11989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
11990 if (!SWIG_IsOK(res1)) {
11991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
11992 }
11993 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
11994 arg2 = obj1;
11995 {
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 wxOutputStream_write(arg1,arg2);
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 resultobj = SWIG_Py_Void();
12002 return resultobj;
12003 fail:
12004 return NULL;
12005 }
12006
12007
12008 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12009 PyObject *resultobj = 0;
12010 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12011 size_t result;
12012 void *argp1 = 0 ;
12013 int res1 = 0 ;
12014 PyObject *swig_obj[1] ;
12015
12016 if (!args) SWIG_fail;
12017 swig_obj[0] = args;
12018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12019 if (!SWIG_IsOK(res1)) {
12020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12021 }
12022 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12023 {
12024 PyThreadState* __tstate = wxPyBeginAllowThreads();
12025 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12026 wxPyEndAllowThreads(__tstate);
12027 if (PyErr_Occurred()) SWIG_fail;
12028 }
12029 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12030 return resultobj;
12031 fail:
12032 return NULL;
12033 }
12034
12035
12036 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12037 PyObject *obj;
12038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12039 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12040 return SWIG_Py_Void();
12041 }
12042
12043 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12044 PyObject *resultobj = 0;
12045 wxInputStream *arg1 = (wxInputStream *) 0 ;
12046 wxString *arg2 = 0 ;
12047 wxString *arg3 = 0 ;
12048 wxString *arg4 = 0 ;
12049 wxDateTime arg5 ;
12050 wxFSFile *result = 0 ;
12051 wxPyInputStream *temp1 ;
12052 bool temp2 = false ;
12053 bool temp3 = false ;
12054 bool temp4 = false ;
12055 void *argp5 ;
12056 int res5 = 0 ;
12057 PyObject * obj0 = 0 ;
12058 PyObject * obj1 = 0 ;
12059 PyObject * obj2 = 0 ;
12060 PyObject * obj3 = 0 ;
12061 PyObject * obj4 = 0 ;
12062 char * kwnames[] = {
12063 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12064 };
12065
12066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12067 {
12068 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12069 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12070 } else {
12071 PyErr_Clear(); // clear the failure of the wxPyConvert above
12072 arg1 = wxPyCBInputStream_create(obj0, true);
12073 if (arg1 == NULL) {
12074 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12075 SWIG_fail;
12076 }
12077 }
12078 }
12079 {
12080 arg2 = wxString_in_helper(obj1);
12081 if (arg2 == NULL) SWIG_fail;
12082 temp2 = true;
12083 }
12084 {
12085 arg3 = wxString_in_helper(obj2);
12086 if (arg3 == NULL) SWIG_fail;
12087 temp3 = true;
12088 }
12089 {
12090 arg4 = wxString_in_helper(obj3);
12091 if (arg4 == NULL) SWIG_fail;
12092 temp4 = true;
12093 }
12094 {
12095 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12096 if (!SWIG_IsOK(res5)) {
12097 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12098 }
12099 if (!argp5) {
12100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12101 } else {
12102 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12103 arg5 = *temp;
12104 if (SWIG_IsNewObj(res5)) delete temp;
12105 }
12106 }
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12110 wxPyEndAllowThreads(__tstate);
12111 if (PyErr_Occurred()) SWIG_fail;
12112 }
12113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12114 {
12115 if (temp2)
12116 delete arg2;
12117 }
12118 {
12119 if (temp3)
12120 delete arg3;
12121 }
12122 {
12123 if (temp4)
12124 delete arg4;
12125 }
12126 return resultobj;
12127 fail:
12128 {
12129 if (temp2)
12130 delete arg2;
12131 }
12132 {
12133 if (temp3)
12134 delete arg3;
12135 }
12136 {
12137 if (temp4)
12138 delete arg4;
12139 }
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *resultobj = 0;
12146 wxFSFile *arg1 = (wxFSFile *) 0 ;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12156 }
12157 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 delete arg1;
12161
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_Py_Void();
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *resultobj = 0;
12174 wxFSFile *arg1 = (wxFSFile *) 0 ;
12175 wxInputStream *result = 0 ;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 PyObject *swig_obj[1] ;
12179
12180 if (!args) SWIG_fail;
12181 swig_obj[0] = args;
12182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12185 }
12186 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (wxInputStream *)(arg1)->GetStream();
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 {
12194 wxPyInputStream * _ptr = NULL;
12195
12196 if (result) {
12197 _ptr = new wxPyInputStream(result);
12198 }
12199 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12200 }
12201 return resultobj;
12202 fail:
12203 return NULL;
12204 }
12205
12206
12207 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208 PyObject *resultobj = 0;
12209 wxFSFile *arg1 = (wxFSFile *) 0 ;
12210 void *argp1 = 0 ;
12211 int res1 = 0 ;
12212 PyObject *swig_obj[1] ;
12213
12214 if (!args) SWIG_fail;
12215 swig_obj[0] = args;
12216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12217 if (!SWIG_IsOK(res1)) {
12218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12219 }
12220 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 (arg1)->DetachStream();
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 resultobj = SWIG_Py_Void();
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12235 PyObject *resultobj = 0;
12236 wxFSFile *arg1 = (wxFSFile *) 0 ;
12237 wxString *result = 0 ;
12238 void *argp1 = 0 ;
12239 int res1 = 0 ;
12240 PyObject *swig_obj[1] ;
12241
12242 if (!args) SWIG_fail;
12243 swig_obj[0] = args;
12244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12245 if (!SWIG_IsOK(res1)) {
12246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12247 }
12248 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12249 {
12250 PyThreadState* __tstate = wxPyBeginAllowThreads();
12251 {
12252 wxString const &_result_ref = (arg1)->GetMimeType();
12253 result = (wxString *) &_result_ref;
12254 }
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 {
12259 #if wxUSE_UNICODE
12260 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12261 #else
12262 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12263 #endif
12264 }
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxFSFile *arg1 = (wxFSFile *) 0 ;
12274 wxString *result = 0 ;
12275 void *argp1 = 0 ;
12276 int res1 = 0 ;
12277 PyObject *swig_obj[1] ;
12278
12279 if (!args) SWIG_fail;
12280 swig_obj[0] = args;
12281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12282 if (!SWIG_IsOK(res1)) {
12283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12284 }
12285 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12286 {
12287 PyThreadState* __tstate = wxPyBeginAllowThreads();
12288 {
12289 wxString const &_result_ref = (arg1)->GetLocation();
12290 result = (wxString *) &_result_ref;
12291 }
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 {
12296 #if wxUSE_UNICODE
12297 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12298 #else
12299 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12300 #endif
12301 }
12302 return resultobj;
12303 fail:
12304 return NULL;
12305 }
12306
12307
12308 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12309 PyObject *resultobj = 0;
12310 wxFSFile *arg1 = (wxFSFile *) 0 ;
12311 wxString *result = 0 ;
12312 void *argp1 = 0 ;
12313 int res1 = 0 ;
12314 PyObject *swig_obj[1] ;
12315
12316 if (!args) SWIG_fail;
12317 swig_obj[0] = args;
12318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12319 if (!SWIG_IsOK(res1)) {
12320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12321 }
12322 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 {
12326 wxString const &_result_ref = (arg1)->GetAnchor();
12327 result = (wxString *) &_result_ref;
12328 }
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 {
12333 #if wxUSE_UNICODE
12334 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12335 #else
12336 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12337 #endif
12338 }
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12346 PyObject *resultobj = 0;
12347 wxFSFile *arg1 = (wxFSFile *) 0 ;
12348 wxDateTime result;
12349 void *argp1 = 0 ;
12350 int res1 = 0 ;
12351 PyObject *swig_obj[1] ;
12352
12353 if (!args) SWIG_fail;
12354 swig_obj[0] = args;
12355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12356 if (!SWIG_IsOK(res1)) {
12357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12358 }
12359 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (arg1)->GetModificationTime();
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *obj;
12375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12376 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12377 return SWIG_Py_Void();
12378 }
12379
12380 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12381 return SWIG_Python_InitShadowInstance(args);
12382 }
12383
12384 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12385 PyObject *resultobj = 0;
12386 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12387 void *argp1 = 0 ;
12388 int res1 = 0 ;
12389 PyObject *swig_obj[1] ;
12390
12391 if (!args) SWIG_fail;
12392 swig_obj[0] = args;
12393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12394 if (!SWIG_IsOK(res1)) {
12395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12396 }
12397 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12398 {
12399 PyThreadState* __tstate = wxPyBeginAllowThreads();
12400 delete arg1;
12401
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 resultobj = SWIG_Py_Void();
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12413 PyObject *obj;
12414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12415 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12416 return SWIG_Py_Void();
12417 }
12418
12419 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12420 PyObject *resultobj = 0;
12421 wxPyFileSystemHandler *result = 0 ;
12422
12423 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12438 PyObject *resultobj = 0;
12439 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12440 PyObject *arg2 = (PyObject *) 0 ;
12441 PyObject *arg3 = (PyObject *) 0 ;
12442 void *argp1 = 0 ;
12443 int res1 = 0 ;
12444 PyObject * obj0 = 0 ;
12445 PyObject * obj1 = 0 ;
12446 PyObject * obj2 = 0 ;
12447 char * kwnames[] = {
12448 (char *) "self",(char *) "self",(char *) "_class", NULL
12449 };
12450
12451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12455 }
12456 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12457 arg2 = obj1;
12458 arg3 = obj2;
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 (arg1)->_setCallbackInfo(arg2,arg3);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_Py_Void();
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = 0;
12474 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12475 wxString *arg2 = 0 ;
12476 bool result;
12477 void *argp1 = 0 ;
12478 int res1 = 0 ;
12479 bool temp2 = false ;
12480 PyObject * obj0 = 0 ;
12481 PyObject * obj1 = 0 ;
12482 char * kwnames[] = {
12483 (char *) "self",(char *) "location", NULL
12484 };
12485
12486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12488 if (!SWIG_IsOK(res1)) {
12489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12490 }
12491 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12492 {
12493 arg2 = wxString_in_helper(obj1);
12494 if (arg2 == NULL) SWIG_fail;
12495 temp2 = true;
12496 }
12497 {
12498 PyThreadState* __tstate = wxPyBeginAllowThreads();
12499 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 {
12504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12505 }
12506 {
12507 if (temp2)
12508 delete arg2;
12509 }
12510 return resultobj;
12511 fail:
12512 {
12513 if (temp2)
12514 delete arg2;
12515 }
12516 return NULL;
12517 }
12518
12519
12520 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12523 wxFileSystem *arg2 = 0 ;
12524 wxString *arg3 = 0 ;
12525 wxFSFile *result = 0 ;
12526 void *argp1 = 0 ;
12527 int res1 = 0 ;
12528 void *argp2 = 0 ;
12529 int res2 = 0 ;
12530 bool temp3 = false ;
12531 PyObject * obj0 = 0 ;
12532 PyObject * obj1 = 0 ;
12533 PyObject * obj2 = 0 ;
12534 char * kwnames[] = {
12535 (char *) "self",(char *) "fs",(char *) "location", NULL
12536 };
12537
12538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12540 if (!SWIG_IsOK(res1)) {
12541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12542 }
12543 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12544 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12545 if (!SWIG_IsOK(res2)) {
12546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12547 }
12548 if (!argp2) {
12549 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12550 }
12551 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12552 {
12553 arg3 = wxString_in_helper(obj2);
12554 if (arg3 == NULL) SWIG_fail;
12555 temp3 = true;
12556 }
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12565 }
12566 {
12567 if (temp3)
12568 delete arg3;
12569 }
12570 return resultobj;
12571 fail:
12572 {
12573 if (temp3)
12574 delete arg3;
12575 }
12576 return NULL;
12577 }
12578
12579
12580 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj = 0;
12582 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12583 wxString *arg2 = 0 ;
12584 int arg3 = (int) 0 ;
12585 wxString result;
12586 void *argp1 = 0 ;
12587 int res1 = 0 ;
12588 bool temp2 = false ;
12589 int val3 ;
12590 int ecode3 = 0 ;
12591 PyObject * obj0 = 0 ;
12592 PyObject * obj1 = 0 ;
12593 PyObject * obj2 = 0 ;
12594 char * kwnames[] = {
12595 (char *) "self",(char *) "spec",(char *) "flags", NULL
12596 };
12597
12598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12600 if (!SWIG_IsOK(res1)) {
12601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12602 }
12603 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12604 {
12605 arg2 = wxString_in_helper(obj1);
12606 if (arg2 == NULL) SWIG_fail;
12607 temp2 = true;
12608 }
12609 if (obj2) {
12610 ecode3 = SWIG_AsVal_int(obj2, &val3);
12611 if (!SWIG_IsOK(ecode3)) {
12612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12613 }
12614 arg3 = static_cast< int >(val3);
12615 }
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 #if wxUSE_UNICODE
12624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12625 #else
12626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12627 #endif
12628 }
12629 {
12630 if (temp2)
12631 delete arg2;
12632 }
12633 return resultobj;
12634 fail:
12635 {
12636 if (temp2)
12637 delete arg2;
12638 }
12639 return NULL;
12640 }
12641
12642
12643 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12644 PyObject *resultobj = 0;
12645 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12646 wxString result;
12647 void *argp1 = 0 ;
12648 int res1 = 0 ;
12649 PyObject *swig_obj[1] ;
12650
12651 if (!args) SWIG_fail;
12652 swig_obj[0] = args;
12653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12656 }
12657 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12658 {
12659 PyThreadState* __tstate = wxPyBeginAllowThreads();
12660 result = (arg1)->FindNext();
12661 wxPyEndAllowThreads(__tstate);
12662 if (PyErr_Occurred()) SWIG_fail;
12663 }
12664 {
12665 #if wxUSE_UNICODE
12666 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12667 #else
12668 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12669 #endif
12670 }
12671 return resultobj;
12672 fail:
12673 return NULL;
12674 }
12675
12676
12677 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12678 PyObject *resultobj = 0;
12679 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12680 wxString *arg2 = 0 ;
12681 wxString result;
12682 void *argp1 = 0 ;
12683 int res1 = 0 ;
12684 bool temp2 = false ;
12685 PyObject * obj0 = 0 ;
12686 PyObject * obj1 = 0 ;
12687 char * kwnames[] = {
12688 (char *) "self",(char *) "location", NULL
12689 };
12690
12691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12693 if (!SWIG_IsOK(res1)) {
12694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12695 }
12696 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12697 {
12698 arg2 = wxString_in_helper(obj1);
12699 if (arg2 == NULL) SWIG_fail;
12700 temp2 = true;
12701 }
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 result = (arg1)->GetProtocol((wxString const &)*arg2);
12705 wxPyEndAllowThreads(__tstate);
12706 if (PyErr_Occurred()) SWIG_fail;
12707 }
12708 {
12709 #if wxUSE_UNICODE
12710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12711 #else
12712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12713 #endif
12714 }
12715 {
12716 if (temp2)
12717 delete arg2;
12718 }
12719 return resultobj;
12720 fail:
12721 {
12722 if (temp2)
12723 delete arg2;
12724 }
12725 return NULL;
12726 }
12727
12728
12729 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12730 PyObject *resultobj = 0;
12731 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12732 wxString *arg2 = 0 ;
12733 wxString result;
12734 void *argp1 = 0 ;
12735 int res1 = 0 ;
12736 bool temp2 = false ;
12737 PyObject * obj0 = 0 ;
12738 PyObject * obj1 = 0 ;
12739 char * kwnames[] = {
12740 (char *) "self",(char *) "location", NULL
12741 };
12742
12743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12745 if (!SWIG_IsOK(res1)) {
12746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12747 }
12748 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12749 {
12750 arg2 = wxString_in_helper(obj1);
12751 if (arg2 == NULL) SWIG_fail;
12752 temp2 = true;
12753 }
12754 {
12755 PyThreadState* __tstate = wxPyBeginAllowThreads();
12756 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12757 wxPyEndAllowThreads(__tstate);
12758 if (PyErr_Occurred()) SWIG_fail;
12759 }
12760 {
12761 #if wxUSE_UNICODE
12762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12763 #else
12764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12765 #endif
12766 }
12767 {
12768 if (temp2)
12769 delete arg2;
12770 }
12771 return resultobj;
12772 fail:
12773 {
12774 if (temp2)
12775 delete arg2;
12776 }
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12784 wxString *arg2 = 0 ;
12785 wxString result;
12786 void *argp1 = 0 ;
12787 int res1 = 0 ;
12788 bool temp2 = false ;
12789 PyObject * obj0 = 0 ;
12790 PyObject * obj1 = 0 ;
12791 char * kwnames[] = {
12792 (char *) "self",(char *) "location", NULL
12793 };
12794
12795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12797 if (!SWIG_IsOK(res1)) {
12798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12799 }
12800 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12801 {
12802 arg2 = wxString_in_helper(obj1);
12803 if (arg2 == NULL) SWIG_fail;
12804 temp2 = true;
12805 }
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (arg1)->GetAnchor((wxString const &)*arg2);
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 #if wxUSE_UNICODE
12814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12815 #else
12816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12817 #endif
12818 }
12819 {
12820 if (temp2)
12821 delete arg2;
12822 }
12823 return resultobj;
12824 fail:
12825 {
12826 if (temp2)
12827 delete arg2;
12828 }
12829 return NULL;
12830 }
12831
12832
12833 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12834 PyObject *resultobj = 0;
12835 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12836 wxString *arg2 = 0 ;
12837 wxString result;
12838 void *argp1 = 0 ;
12839 int res1 = 0 ;
12840 bool temp2 = false ;
12841 PyObject * obj0 = 0 ;
12842 PyObject * obj1 = 0 ;
12843 char * kwnames[] = {
12844 (char *) "self",(char *) "location", NULL
12845 };
12846
12847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12849 if (!SWIG_IsOK(res1)) {
12850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12851 }
12852 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12853 {
12854 arg2 = wxString_in_helper(obj1);
12855 if (arg2 == NULL) SWIG_fail;
12856 temp2 = true;
12857 }
12858 {
12859 PyThreadState* __tstate = wxPyBeginAllowThreads();
12860 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 {
12865 #if wxUSE_UNICODE
12866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12867 #else
12868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12869 #endif
12870 }
12871 {
12872 if (temp2)
12873 delete arg2;
12874 }
12875 return resultobj;
12876 fail:
12877 {
12878 if (temp2)
12879 delete arg2;
12880 }
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12886 PyObject *resultobj = 0;
12887 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12888 wxString *arg2 = 0 ;
12889 wxString result;
12890 void *argp1 = 0 ;
12891 int res1 = 0 ;
12892 bool temp2 = false ;
12893 PyObject * obj0 = 0 ;
12894 PyObject * obj1 = 0 ;
12895 char * kwnames[] = {
12896 (char *) "self",(char *) "location", NULL
12897 };
12898
12899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12901 if (!SWIG_IsOK(res1)) {
12902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12903 }
12904 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12905 {
12906 arg2 = wxString_in_helper(obj1);
12907 if (arg2 == NULL) SWIG_fail;
12908 temp2 = true;
12909 }
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 {
12917 #if wxUSE_UNICODE
12918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12919 #else
12920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12921 #endif
12922 }
12923 {
12924 if (temp2)
12925 delete arg2;
12926 }
12927 return resultobj;
12928 fail:
12929 {
12930 if (temp2)
12931 delete arg2;
12932 }
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *obj;
12939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12940 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12941 return SWIG_Py_Void();
12942 }
12943
12944 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12945 return SWIG_Python_InitShadowInstance(args);
12946 }
12947
12948 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12949 PyObject *resultobj = 0;
12950 wxFileSystem *result = 0 ;
12951
12952 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
12953 {
12954 PyThreadState* __tstate = wxPyBeginAllowThreads();
12955 result = (wxFileSystem *)new wxFileSystem();
12956 wxPyEndAllowThreads(__tstate);
12957 if (PyErr_Occurred()) SWIG_fail;
12958 }
12959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 PyObject *resultobj = 0;
12968 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 PyObject *swig_obj[1] ;
12972
12973 if (!args) SWIG_fail;
12974 swig_obj[0] = args;
12975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
12976 if (!SWIG_IsOK(res1)) {
12977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
12978 }
12979 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 delete arg1;
12983
12984 wxPyEndAllowThreads(__tstate);
12985 if (PyErr_Occurred()) SWIG_fail;
12986 }
12987 resultobj = SWIG_Py_Void();
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj = 0;
12996 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
12997 wxString *arg2 = 0 ;
12998 bool arg3 = (bool) false ;
12999 void *argp1 = 0 ;
13000 int res1 = 0 ;
13001 bool temp2 = false ;
13002 bool val3 ;
13003 int ecode3 = 0 ;
13004 PyObject * obj0 = 0 ;
13005 PyObject * obj1 = 0 ;
13006 PyObject * obj2 = 0 ;
13007 char * kwnames[] = {
13008 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13009 };
13010
13011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13013 if (!SWIG_IsOK(res1)) {
13014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13015 }
13016 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13017 {
13018 arg2 = wxString_in_helper(obj1);
13019 if (arg2 == NULL) SWIG_fail;
13020 temp2 = true;
13021 }
13022 if (obj2) {
13023 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13024 if (!SWIG_IsOK(ecode3)) {
13025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13026 }
13027 arg3 = static_cast< bool >(val3);
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 resultobj = SWIG_Py_Void();
13036 {
13037 if (temp2)
13038 delete arg2;
13039 }
13040 return resultobj;
13041 fail:
13042 {
13043 if (temp2)
13044 delete arg2;
13045 }
13046 return NULL;
13047 }
13048
13049
13050 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13051 PyObject *resultobj = 0;
13052 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13053 wxString result;
13054 void *argp1 = 0 ;
13055 int res1 = 0 ;
13056 PyObject *swig_obj[1] ;
13057
13058 if (!args) SWIG_fail;
13059 swig_obj[0] = args;
13060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13061 if (!SWIG_IsOK(res1)) {
13062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13063 }
13064 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = (arg1)->GetPath();
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 {
13072 #if wxUSE_UNICODE
13073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13074 #else
13075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13076 #endif
13077 }
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13085 PyObject *resultobj = 0;
13086 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13087 wxString *arg2 = 0 ;
13088 wxFSFile *result = 0 ;
13089 void *argp1 = 0 ;
13090 int res1 = 0 ;
13091 bool temp2 = false ;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 char * kwnames[] = {
13095 (char *) "self",(char *) "location", NULL
13096 };
13097
13098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13100 if (!SWIG_IsOK(res1)) {
13101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13102 }
13103 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13104 {
13105 arg2 = wxString_in_helper(obj1);
13106 if (arg2 == NULL) SWIG_fail;
13107 temp2 = true;
13108 }
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13112 wxPyEndAllowThreads(__tstate);
13113 if (PyErr_Occurred()) SWIG_fail;
13114 }
13115 {
13116 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13117 }
13118 {
13119 if (temp2)
13120 delete arg2;
13121 }
13122 return resultobj;
13123 fail:
13124 {
13125 if (temp2)
13126 delete arg2;
13127 }
13128 return NULL;
13129 }
13130
13131
13132 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13133 PyObject *resultobj = 0;
13134 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13135 wxString *arg2 = 0 ;
13136 int arg3 = (int) 0 ;
13137 wxString result;
13138 void *argp1 = 0 ;
13139 int res1 = 0 ;
13140 bool temp2 = false ;
13141 int val3 ;
13142 int ecode3 = 0 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 PyObject * obj2 = 0 ;
13146 char * kwnames[] = {
13147 (char *) "self",(char *) "spec",(char *) "flags", NULL
13148 };
13149
13150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13152 if (!SWIG_IsOK(res1)) {
13153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13154 }
13155 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13156 {
13157 arg2 = wxString_in_helper(obj1);
13158 if (arg2 == NULL) SWIG_fail;
13159 temp2 = true;
13160 }
13161 if (obj2) {
13162 ecode3 = SWIG_AsVal_int(obj2, &val3);
13163 if (!SWIG_IsOK(ecode3)) {
13164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13165 }
13166 arg3 = static_cast< int >(val3);
13167 }
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 {
13175 #if wxUSE_UNICODE
13176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13177 #else
13178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13179 #endif
13180 }
13181 {
13182 if (temp2)
13183 delete arg2;
13184 }
13185 return resultobj;
13186 fail:
13187 {
13188 if (temp2)
13189 delete arg2;
13190 }
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13196 PyObject *resultobj = 0;
13197 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13198 wxString result;
13199 void *argp1 = 0 ;
13200 int res1 = 0 ;
13201 PyObject *swig_obj[1] ;
13202
13203 if (!args) SWIG_fail;
13204 swig_obj[0] = args;
13205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13206 if (!SWIG_IsOK(res1)) {
13207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13208 }
13209 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13210 {
13211 PyThreadState* __tstate = wxPyBeginAllowThreads();
13212 result = (arg1)->FindNext();
13213 wxPyEndAllowThreads(__tstate);
13214 if (PyErr_Occurred()) SWIG_fail;
13215 }
13216 {
13217 #if wxUSE_UNICODE
13218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13219 #else
13220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13221 #endif
13222 }
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj = 0;
13231 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13232 int res1 = 0 ;
13233 PyObject * obj0 = 0 ;
13234 char * kwnames[] = {
13235 (char *) "handler", NULL
13236 };
13237
13238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13239 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13240 if (!SWIG_IsOK(res1)) {
13241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 wxFileSystem::AddHandler(arg1);
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 resultobj = SWIG_Py_Void();
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = 0;
13258 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13259 wxFileSystemHandler *result = 0 ;
13260 void *argp1 = 0 ;
13261 int res1 = 0 ;
13262 PyObject * obj0 = 0 ;
13263 char * kwnames[] = {
13264 (char *) "handler", NULL
13265 };
13266
13267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13269 if (!SWIG_IsOK(res1)) {
13270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13271 }
13272 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13273 {
13274 PyThreadState* __tstate = wxPyBeginAllowThreads();
13275 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13287 PyObject *resultobj = 0;
13288
13289 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 wxFileSystem::CleanUpHandlers();
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 resultobj = SWIG_Py_Void();
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = 0;
13305 wxString *arg1 = 0 ;
13306 wxString result;
13307 bool temp1 = false ;
13308 PyObject * obj0 = 0 ;
13309 char * kwnames[] = {
13310 (char *) "filename", NULL
13311 };
13312
13313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13314 {
13315 arg1 = wxString_in_helper(obj0);
13316 if (arg1 == NULL) SWIG_fail;
13317 temp1 = true;
13318 }
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 {
13326 #if wxUSE_UNICODE
13327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13328 #else
13329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13330 #endif
13331 }
13332 {
13333 if (temp1)
13334 delete arg1;
13335 }
13336 return resultobj;
13337 fail:
13338 {
13339 if (temp1)
13340 delete arg1;
13341 }
13342 return NULL;
13343 }
13344
13345
13346 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13347 PyObject *resultobj = 0;
13348 wxString *arg1 = 0 ;
13349 wxString result;
13350 bool temp1 = false ;
13351 PyObject * obj0 = 0 ;
13352 char * kwnames[] = {
13353 (char *) "url", NULL
13354 };
13355
13356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13357 {
13358 arg1 = wxString_in_helper(obj0);
13359 if (arg1 == NULL) SWIG_fail;
13360 temp1 = true;
13361 }
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 {
13369 #if wxUSE_UNICODE
13370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13371 #else
13372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13373 #endif
13374 }
13375 {
13376 if (temp1)
13377 delete arg1;
13378 }
13379 return resultobj;
13380 fail:
13381 {
13382 if (temp1)
13383 delete arg1;
13384 }
13385 return NULL;
13386 }
13387
13388
13389 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13390 PyObject *obj;
13391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13392 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13393 return SWIG_Py_Void();
13394 }
13395
13396 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13397 return SWIG_Python_InitShadowInstance(args);
13398 }
13399
13400 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *resultobj = 0;
13402 wxInternetFSHandler *result = 0 ;
13403
13404 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13405 {
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj = 0;
13420 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13421 wxString *arg2 = 0 ;
13422 bool result;
13423 void *argp1 = 0 ;
13424 int res1 = 0 ;
13425 bool temp2 = false ;
13426 PyObject * obj0 = 0 ;
13427 PyObject * obj1 = 0 ;
13428 char * kwnames[] = {
13429 (char *) "self",(char *) "location", NULL
13430 };
13431
13432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13434 if (!SWIG_IsOK(res1)) {
13435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13436 }
13437 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13438 {
13439 arg2 = wxString_in_helper(obj1);
13440 if (arg2 == NULL) SWIG_fail;
13441 temp2 = true;
13442 }
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 {
13450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13451 }
13452 {
13453 if (temp2)
13454 delete arg2;
13455 }
13456 return resultobj;
13457 fail:
13458 {
13459 if (temp2)
13460 delete arg2;
13461 }
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj = 0;
13468 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13469 wxFileSystem *arg2 = 0 ;
13470 wxString *arg3 = 0 ;
13471 wxFSFile *result = 0 ;
13472 void *argp1 = 0 ;
13473 int res1 = 0 ;
13474 void *argp2 = 0 ;
13475 int res2 = 0 ;
13476 bool temp3 = false ;
13477 PyObject * obj0 = 0 ;
13478 PyObject * obj1 = 0 ;
13479 PyObject * obj2 = 0 ;
13480 char * kwnames[] = {
13481 (char *) "self",(char *) "fs",(char *) "location", NULL
13482 };
13483
13484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13486 if (!SWIG_IsOK(res1)) {
13487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13488 }
13489 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13491 if (!SWIG_IsOK(res2)) {
13492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13493 }
13494 if (!argp2) {
13495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13496 }
13497 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13498 {
13499 arg3 = wxString_in_helper(obj2);
13500 if (arg3 == NULL) SWIG_fail;
13501 temp3 = true;
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 {
13510 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13511 }
13512 {
13513 if (temp3)
13514 delete arg3;
13515 }
13516 return resultobj;
13517 fail:
13518 {
13519 if (temp3)
13520 delete arg3;
13521 }
13522 return NULL;
13523 }
13524
13525
13526 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13527 PyObject *obj;
13528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13529 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13530 return SWIG_Py_Void();
13531 }
13532
13533 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13534 return SWIG_Python_InitShadowInstance(args);
13535 }
13536
13537 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13538 PyObject *resultobj = 0;
13539 wxZipFSHandler *result = 0 ;
13540
13541 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13542 {
13543 PyThreadState* __tstate = wxPyBeginAllowThreads();
13544 result = (wxZipFSHandler *)new wxZipFSHandler();
13545 wxPyEndAllowThreads(__tstate);
13546 if (PyErr_Occurred()) SWIG_fail;
13547 }
13548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13549 return resultobj;
13550 fail:
13551 return NULL;
13552 }
13553
13554
13555 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13556 PyObject *resultobj = 0;
13557 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13558 wxString *arg2 = 0 ;
13559 bool result;
13560 void *argp1 = 0 ;
13561 int res1 = 0 ;
13562 bool temp2 = false ;
13563 PyObject * obj0 = 0 ;
13564 PyObject * obj1 = 0 ;
13565 char * kwnames[] = {
13566 (char *) "self",(char *) "location", NULL
13567 };
13568
13569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13571 if (!SWIG_IsOK(res1)) {
13572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13573 }
13574 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13575 {
13576 arg2 = wxString_in_helper(obj1);
13577 if (arg2 == NULL) SWIG_fail;
13578 temp2 = true;
13579 }
13580 {
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13583 wxPyEndAllowThreads(__tstate);
13584 if (PyErr_Occurred()) SWIG_fail;
13585 }
13586 {
13587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13588 }
13589 {
13590 if (temp2)
13591 delete arg2;
13592 }
13593 return resultobj;
13594 fail:
13595 {
13596 if (temp2)
13597 delete arg2;
13598 }
13599 return NULL;
13600 }
13601
13602
13603 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = 0;
13605 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13606 wxFileSystem *arg2 = 0 ;
13607 wxString *arg3 = 0 ;
13608 wxFSFile *result = 0 ;
13609 void *argp1 = 0 ;
13610 int res1 = 0 ;
13611 void *argp2 = 0 ;
13612 int res2 = 0 ;
13613 bool temp3 = false ;
13614 PyObject * obj0 = 0 ;
13615 PyObject * obj1 = 0 ;
13616 PyObject * obj2 = 0 ;
13617 char * kwnames[] = {
13618 (char *) "self",(char *) "fs",(char *) "location", NULL
13619 };
13620
13621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13623 if (!SWIG_IsOK(res1)) {
13624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13625 }
13626 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13628 if (!SWIG_IsOK(res2)) {
13629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13630 }
13631 if (!argp2) {
13632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13633 }
13634 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13635 {
13636 arg3 = wxString_in_helper(obj2);
13637 if (arg3 == NULL) SWIG_fail;
13638 temp3 = true;
13639 }
13640 {
13641 PyThreadState* __tstate = wxPyBeginAllowThreads();
13642 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 {
13647 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13648 }
13649 {
13650 if (temp3)
13651 delete arg3;
13652 }
13653 return resultobj;
13654 fail:
13655 {
13656 if (temp3)
13657 delete arg3;
13658 }
13659 return NULL;
13660 }
13661
13662
13663 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13664 PyObject *resultobj = 0;
13665 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13666 wxString *arg2 = 0 ;
13667 int arg3 = (int) 0 ;
13668 wxString result;
13669 void *argp1 = 0 ;
13670 int res1 = 0 ;
13671 bool temp2 = false ;
13672 int val3 ;
13673 int ecode3 = 0 ;
13674 PyObject * obj0 = 0 ;
13675 PyObject * obj1 = 0 ;
13676 PyObject * obj2 = 0 ;
13677 char * kwnames[] = {
13678 (char *) "self",(char *) "spec",(char *) "flags", NULL
13679 };
13680
13681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13683 if (!SWIG_IsOK(res1)) {
13684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13685 }
13686 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13687 {
13688 arg2 = wxString_in_helper(obj1);
13689 if (arg2 == NULL) SWIG_fail;
13690 temp2 = true;
13691 }
13692 if (obj2) {
13693 ecode3 = SWIG_AsVal_int(obj2, &val3);
13694 if (!SWIG_IsOK(ecode3)) {
13695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13696 }
13697 arg3 = static_cast< int >(val3);
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 #if wxUSE_UNICODE
13707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13708 #else
13709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13710 #endif
13711 }
13712 {
13713 if (temp2)
13714 delete arg2;
13715 }
13716 return resultobj;
13717 fail:
13718 {
13719 if (temp2)
13720 delete arg2;
13721 }
13722 return NULL;
13723 }
13724
13725
13726 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13727 PyObject *resultobj = 0;
13728 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13729 wxString result;
13730 void *argp1 = 0 ;
13731 int res1 = 0 ;
13732 PyObject *swig_obj[1] ;
13733
13734 if (!args) SWIG_fail;
13735 swig_obj[0] = args;
13736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13737 if (!SWIG_IsOK(res1)) {
13738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13739 }
13740 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13741 {
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 result = (arg1)->FindNext();
13744 wxPyEndAllowThreads(__tstate);
13745 if (PyErr_Occurred()) SWIG_fail;
13746 }
13747 {
13748 #if wxUSE_UNICODE
13749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13750 #else
13751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13752 #endif
13753 }
13754 return resultobj;
13755 fail:
13756 return NULL;
13757 }
13758
13759
13760 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13761 PyObject *obj;
13762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13763 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13764 return SWIG_Py_Void();
13765 }
13766
13767 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13768 return SWIG_Python_InitShadowInstance(args);
13769 }
13770
13771 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13772 PyObject *resultobj = 0;
13773 wxString *arg1 = 0 ;
13774 wxImage *arg2 = 0 ;
13775 long arg3 ;
13776 bool temp1 = false ;
13777 void *argp2 = 0 ;
13778 int res2 = 0 ;
13779 long val3 ;
13780 int ecode3 = 0 ;
13781 PyObject * obj0 = 0 ;
13782 PyObject * obj1 = 0 ;
13783 PyObject * obj2 = 0 ;
13784 char * kwnames[] = {
13785 (char *) "filename",(char *) "image",(char *) "type", NULL
13786 };
13787
13788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13789 {
13790 arg1 = wxString_in_helper(obj0);
13791 if (arg1 == NULL) SWIG_fail;
13792 temp1 = true;
13793 }
13794 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13795 if (!SWIG_IsOK(res2)) {
13796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13797 }
13798 if (!argp2) {
13799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13800 }
13801 arg2 = reinterpret_cast< wxImage * >(argp2);
13802 ecode3 = SWIG_AsVal_long(obj2, &val3);
13803 if (!SWIG_IsOK(ecode3)) {
13804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13805 }
13806 arg3 = static_cast< long >(val3);
13807 {
13808 PyThreadState* __tstate = wxPyBeginAllowThreads();
13809 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13810 wxPyEndAllowThreads(__tstate);
13811 if (PyErr_Occurred()) SWIG_fail;
13812 }
13813 resultobj = SWIG_Py_Void();
13814 {
13815 if (temp1)
13816 delete arg1;
13817 }
13818 return resultobj;
13819 fail:
13820 {
13821 if (temp1)
13822 delete arg1;
13823 }
13824 return NULL;
13825 }
13826
13827
13828 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj = 0;
13830 wxString *arg1 = 0 ;
13831 wxBitmap *arg2 = 0 ;
13832 long arg3 ;
13833 bool temp1 = false ;
13834 void *argp2 = 0 ;
13835 int res2 = 0 ;
13836 long val3 ;
13837 int ecode3 = 0 ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 char * kwnames[] = {
13842 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13843 };
13844
13845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13846 {
13847 arg1 = wxString_in_helper(obj0);
13848 if (arg1 == NULL) SWIG_fail;
13849 temp1 = true;
13850 }
13851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13852 if (!SWIG_IsOK(res2)) {
13853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13854 }
13855 if (!argp2) {
13856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13857 }
13858 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13859 ecode3 = SWIG_AsVal_long(obj2, &val3);
13860 if (!SWIG_IsOK(ecode3)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13862 }
13863 arg3 = static_cast< long >(val3);
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13867 wxPyEndAllowThreads(__tstate);
13868 if (PyErr_Occurred()) SWIG_fail;
13869 }
13870 resultobj = SWIG_Py_Void();
13871 {
13872 if (temp1)
13873 delete arg1;
13874 }
13875 return resultobj;
13876 fail:
13877 {
13878 if (temp1)
13879 delete arg1;
13880 }
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxString *arg1 = 0 ;
13888 PyObject *arg2 = (PyObject *) 0 ;
13889 bool temp1 = false ;
13890 PyObject * obj0 = 0 ;
13891 PyObject * obj1 = 0 ;
13892 char * kwnames[] = {
13893 (char *) "filename",(char *) "data", NULL
13894 };
13895
13896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13897 {
13898 arg1 = wxString_in_helper(obj0);
13899 if (arg1 == NULL) SWIG_fail;
13900 temp1 = true;
13901 }
13902 arg2 = obj1;
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 resultobj = SWIG_Py_Void();
13910 {
13911 if (temp1)
13912 delete arg1;
13913 }
13914 return resultobj;
13915 fail:
13916 {
13917 if (temp1)
13918 delete arg1;
13919 }
13920 return NULL;
13921 }
13922
13923
13924 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13925 PyObject *resultobj = 0;
13926 wxMemoryFSHandler *result = 0 ;
13927
13928 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13943 PyObject *resultobj = 0;
13944 wxString *arg1 = 0 ;
13945 bool temp1 = false ;
13946 PyObject * obj0 = 0 ;
13947 char * kwnames[] = {
13948 (char *) "filename", NULL
13949 };
13950
13951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
13952 {
13953 arg1 = wxString_in_helper(obj0);
13954 if (arg1 == NULL) SWIG_fail;
13955 temp1 = true;
13956 }
13957 {
13958 PyThreadState* __tstate = wxPyBeginAllowThreads();
13959 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
13960 wxPyEndAllowThreads(__tstate);
13961 if (PyErr_Occurred()) SWIG_fail;
13962 }
13963 resultobj = SWIG_Py_Void();
13964 {
13965 if (temp1)
13966 delete arg1;
13967 }
13968 return resultobj;
13969 fail:
13970 {
13971 if (temp1)
13972 delete arg1;
13973 }
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj = 0;
13980 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
13981 wxString *arg2 = 0 ;
13982 bool result;
13983 void *argp1 = 0 ;
13984 int res1 = 0 ;
13985 bool temp2 = false ;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 char * kwnames[] = {
13989 (char *) "self",(char *) "location", NULL
13990 };
13991
13992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
13994 if (!SWIG_IsOK(res1)) {
13995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
13996 }
13997 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
13998 {
13999 arg2 = wxString_in_helper(obj1);
14000 if (arg2 == NULL) SWIG_fail;
14001 temp2 = true;
14002 }
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 {
14010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14011 }
14012 {
14013 if (temp2)
14014 delete arg2;
14015 }
14016 return resultobj;
14017 fail:
14018 {
14019 if (temp2)
14020 delete arg2;
14021 }
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14029 wxFileSystem *arg2 = 0 ;
14030 wxString *arg3 = 0 ;
14031 wxFSFile *result = 0 ;
14032 void *argp1 = 0 ;
14033 int res1 = 0 ;
14034 void *argp2 = 0 ;
14035 int res2 = 0 ;
14036 bool temp3 = false ;
14037 PyObject * obj0 = 0 ;
14038 PyObject * obj1 = 0 ;
14039 PyObject * obj2 = 0 ;
14040 char * kwnames[] = {
14041 (char *) "self",(char *) "fs",(char *) "location", NULL
14042 };
14043
14044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14046 if (!SWIG_IsOK(res1)) {
14047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14048 }
14049 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14051 if (!SWIG_IsOK(res2)) {
14052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14053 }
14054 if (!argp2) {
14055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14056 }
14057 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14058 {
14059 arg3 = wxString_in_helper(obj2);
14060 if (arg3 == NULL) SWIG_fail;
14061 temp3 = true;
14062 }
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 {
14070 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14071 }
14072 {
14073 if (temp3)
14074 delete arg3;
14075 }
14076 return resultobj;
14077 fail:
14078 {
14079 if (temp3)
14080 delete arg3;
14081 }
14082 return NULL;
14083 }
14084
14085
14086 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj = 0;
14088 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14089 wxString *arg2 = 0 ;
14090 int arg3 = (int) 0 ;
14091 wxString result;
14092 void *argp1 = 0 ;
14093 int res1 = 0 ;
14094 bool temp2 = false ;
14095 int val3 ;
14096 int ecode3 = 0 ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "spec",(char *) "flags", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14108 }
14109 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14110 {
14111 arg2 = wxString_in_helper(obj1);
14112 if (arg2 == NULL) SWIG_fail;
14113 temp2 = true;
14114 }
14115 if (obj2) {
14116 ecode3 = SWIG_AsVal_int(obj2, &val3);
14117 if (!SWIG_IsOK(ecode3)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14119 }
14120 arg3 = static_cast< int >(val3);
14121 }
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 #if wxUSE_UNICODE
14130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14131 #else
14132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14133 #endif
14134 }
14135 {
14136 if (temp2)
14137 delete arg2;
14138 }
14139 return resultobj;
14140 fail:
14141 {
14142 if (temp2)
14143 delete arg2;
14144 }
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14150 PyObject *resultobj = 0;
14151 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14152 wxString result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 PyObject *swig_obj[1] ;
14156
14157 if (!args) SWIG_fail;
14158 swig_obj[0] = args;
14159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14160 if (!SWIG_IsOK(res1)) {
14161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14162 }
14163 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = (arg1)->FindNext();
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 {
14171 #if wxUSE_UNICODE
14172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14173 #else
14174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14175 #endif
14176 }
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14184 PyObject *obj;
14185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14186 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14187 return SWIG_Py_Void();
14188 }
14189
14190 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191 return SWIG_Python_InitShadowInstance(args);
14192 }
14193
14194 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14195 PyObject *resultobj = 0;
14196 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14197 wxString result;
14198 void *argp1 = 0 ;
14199 int res1 = 0 ;
14200 PyObject *swig_obj[1] ;
14201
14202 if (!args) SWIG_fail;
14203 swig_obj[0] = args;
14204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14205 if (!SWIG_IsOK(res1)) {
14206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14207 }
14208 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (arg1)->GetName();
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 {
14216 #if wxUSE_UNICODE
14217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14218 #else
14219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14220 #endif
14221 }
14222 return resultobj;
14223 fail:
14224 return NULL;
14225 }
14226
14227
14228 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14229 PyObject *resultobj = 0;
14230 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14231 wxString result;
14232 void *argp1 = 0 ;
14233 int res1 = 0 ;
14234 PyObject *swig_obj[1] ;
14235
14236 if (!args) SWIG_fail;
14237 swig_obj[0] = args;
14238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14239 if (!SWIG_IsOK(res1)) {
14240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14241 }
14242 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14243 {
14244 PyThreadState* __tstate = wxPyBeginAllowThreads();
14245 result = (arg1)->GetExtension();
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 {
14250 #if wxUSE_UNICODE
14251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14252 #else
14253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14254 #endif
14255 }
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14263 PyObject *resultobj = 0;
14264 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14265 long result;
14266 void *argp1 = 0 ;
14267 int res1 = 0 ;
14268 PyObject *swig_obj[1] ;
14269
14270 if (!args) SWIG_fail;
14271 swig_obj[0] = args;
14272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14273 if (!SWIG_IsOK(res1)) {
14274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14275 }
14276 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14277 {
14278 PyThreadState* __tstate = wxPyBeginAllowThreads();
14279 result = (long)(arg1)->GetType();
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 resultobj = SWIG_From_long(static_cast< long >(result));
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14291 PyObject *resultobj = 0;
14292 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14293 wxString result;
14294 void *argp1 = 0 ;
14295 int res1 = 0 ;
14296 PyObject *swig_obj[1] ;
14297
14298 if (!args) SWIG_fail;
14299 swig_obj[0] = args;
14300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14301 if (!SWIG_IsOK(res1)) {
14302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14303 }
14304 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14305 {
14306 PyThreadState* __tstate = wxPyBeginAllowThreads();
14307 result = (arg1)->GetMimeType();
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 {
14312 #if wxUSE_UNICODE
14313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14314 #else
14315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14316 #endif
14317 }
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14325 PyObject *resultobj = 0;
14326 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14327 wxString *arg2 = 0 ;
14328 bool result;
14329 void *argp1 = 0 ;
14330 int res1 = 0 ;
14331 bool temp2 = false ;
14332 PyObject * obj0 = 0 ;
14333 PyObject * obj1 = 0 ;
14334 char * kwnames[] = {
14335 (char *) "self",(char *) "name", NULL
14336 };
14337
14338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14340 if (!SWIG_IsOK(res1)) {
14341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14342 }
14343 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14344 {
14345 arg2 = wxString_in_helper(obj1);
14346 if (arg2 == NULL) SWIG_fail;
14347 temp2 = true;
14348 }
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 {
14356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14357 }
14358 {
14359 if (temp2)
14360 delete arg2;
14361 }
14362 return resultobj;
14363 fail:
14364 {
14365 if (temp2)
14366 delete arg2;
14367 }
14368 return NULL;
14369 }
14370
14371
14372 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj = 0;
14374 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14375 wxInputStream *arg2 = 0 ;
14376 bool result;
14377 void *argp1 = 0 ;
14378 int res1 = 0 ;
14379 wxPyInputStream *temp2 ;
14380 bool created2 ;
14381 PyObject * obj0 = 0 ;
14382 PyObject * obj1 = 0 ;
14383 char * kwnames[] = {
14384 (char *) "self",(char *) "stream", NULL
14385 };
14386
14387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14389 if (!SWIG_IsOK(res1)) {
14390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14391 }
14392 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14393 {
14394 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14395 arg2 = temp2->m_wxis;
14396 created2 = false;
14397 } else {
14398 PyErr_Clear(); // clear the failure of the wxPyConvert above
14399 arg2 = wxPyCBInputStream_create(obj1, false);
14400 if (arg2 == NULL) {
14401 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14402 SWIG_fail;
14403 }
14404 created2 = true;
14405 }
14406 }
14407 {
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 result = (bool)(arg1)->CanRead(*arg2);
14410 wxPyEndAllowThreads(__tstate);
14411 if (PyErr_Occurred()) SWIG_fail;
14412 }
14413 {
14414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14415 }
14416 {
14417 if (created2) delete arg2;
14418 }
14419 return resultobj;
14420 fail:
14421 {
14422 if (created2) delete arg2;
14423 }
14424 return NULL;
14425 }
14426
14427
14428 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14429 PyObject *resultobj = 0;
14430 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14431 wxString *arg2 = 0 ;
14432 void *argp1 = 0 ;
14433 int res1 = 0 ;
14434 bool temp2 = false ;
14435 PyObject * obj0 = 0 ;
14436 PyObject * obj1 = 0 ;
14437 char * kwnames[] = {
14438 (char *) "self",(char *) "name", NULL
14439 };
14440
14441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14443 if (!SWIG_IsOK(res1)) {
14444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14445 }
14446 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14447 {
14448 arg2 = wxString_in_helper(obj1);
14449 if (arg2 == NULL) SWIG_fail;
14450 temp2 = true;
14451 }
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 (arg1)->SetName((wxString const &)*arg2);
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 resultobj = SWIG_Py_Void();
14459 {
14460 if (temp2)
14461 delete arg2;
14462 }
14463 return resultobj;
14464 fail:
14465 {
14466 if (temp2)
14467 delete arg2;
14468 }
14469 return NULL;
14470 }
14471
14472
14473 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14474 PyObject *resultobj = 0;
14475 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14476 wxString *arg2 = 0 ;
14477 void *argp1 = 0 ;
14478 int res1 = 0 ;
14479 bool temp2 = false ;
14480 PyObject * obj0 = 0 ;
14481 PyObject * obj1 = 0 ;
14482 char * kwnames[] = {
14483 (char *) "self",(char *) "extension", NULL
14484 };
14485
14486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14488 if (!SWIG_IsOK(res1)) {
14489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14490 }
14491 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14492 {
14493 arg2 = wxString_in_helper(obj1);
14494 if (arg2 == NULL) SWIG_fail;
14495 temp2 = true;
14496 }
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 (arg1)->SetExtension((wxString const &)*arg2);
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 resultobj = SWIG_Py_Void();
14504 {
14505 if (temp2)
14506 delete arg2;
14507 }
14508 return resultobj;
14509 fail:
14510 {
14511 if (temp2)
14512 delete arg2;
14513 }
14514 return NULL;
14515 }
14516
14517
14518 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14519 PyObject *resultobj = 0;
14520 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14521 long arg2 ;
14522 void *argp1 = 0 ;
14523 int res1 = 0 ;
14524 long val2 ;
14525 int ecode2 = 0 ;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 char * kwnames[] = {
14529 (char *) "self",(char *) "type", NULL
14530 };
14531
14532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14534 if (!SWIG_IsOK(res1)) {
14535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14536 }
14537 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14538 ecode2 = SWIG_AsVal_long(obj1, &val2);
14539 if (!SWIG_IsOK(ecode2)) {
14540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14541 }
14542 arg2 = static_cast< long >(val2);
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->SetType(arg2);
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = SWIG_Py_Void();
14550 return resultobj;
14551 fail:
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14557 PyObject *resultobj = 0;
14558 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14559 wxString *arg2 = 0 ;
14560 void *argp1 = 0 ;
14561 int res1 = 0 ;
14562 bool temp2 = false ;
14563 PyObject * obj0 = 0 ;
14564 PyObject * obj1 = 0 ;
14565 char * kwnames[] = {
14566 (char *) "self",(char *) "mimetype", NULL
14567 };
14568
14569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14571 if (!SWIG_IsOK(res1)) {
14572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14573 }
14574 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14575 {
14576 arg2 = wxString_in_helper(obj1);
14577 if (arg2 == NULL) SWIG_fail;
14578 temp2 = true;
14579 }
14580 {
14581 PyThreadState* __tstate = wxPyBeginAllowThreads();
14582 (arg1)->SetMimeType((wxString const &)*arg2);
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 resultobj = SWIG_Py_Void();
14587 {
14588 if (temp2)
14589 delete arg2;
14590 }
14591 return resultobj;
14592 fail:
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 return NULL;
14598 }
14599
14600
14601 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14602 PyObject *obj;
14603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14604 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14605 return SWIG_Py_Void();
14606 }
14607
14608 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14609 PyObject *resultobj = 0;
14610 wxPyImageHandler *result = 0 ;
14611
14612 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 result = (wxPyImageHandler *)new wxPyImageHandler();
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14620 return resultobj;
14621 fail:
14622 return NULL;
14623 }
14624
14625
14626 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14627 PyObject *resultobj = 0;
14628 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14629 PyObject *arg2 = (PyObject *) 0 ;
14630 void *argp1 = 0 ;
14631 int res1 = 0 ;
14632 PyObject * obj0 = 0 ;
14633 PyObject * obj1 = 0 ;
14634 char * kwnames[] = {
14635 (char *) "self",(char *) "self", NULL
14636 };
14637
14638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14640 if (!SWIG_IsOK(res1)) {
14641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14642 }
14643 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14644 arg2 = obj1;
14645 {
14646 PyThreadState* __tstate = wxPyBeginAllowThreads();
14647 (arg1)->_SetSelf(arg2);
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 resultobj = SWIG_Py_Void();
14652 return resultobj;
14653 fail:
14654 return NULL;
14655 }
14656
14657
14658 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14659 PyObject *obj;
14660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14661 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14662 return SWIG_Py_Void();
14663 }
14664
14665 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14666 return SWIG_Python_InitShadowInstance(args);
14667 }
14668
14669 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14670 PyObject *resultobj = 0;
14671 wxImageHistogram *result = 0 ;
14672
14673 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (wxImageHistogram *)new wxImageHistogram();
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj = 0;
14689 byte arg1 ;
14690 byte arg2 ;
14691 byte arg3 ;
14692 unsigned long result;
14693 unsigned char val1 ;
14694 int ecode1 = 0 ;
14695 unsigned char val2 ;
14696 int ecode2 = 0 ;
14697 unsigned char val3 ;
14698 int ecode3 = 0 ;
14699 PyObject * obj0 = 0 ;
14700 PyObject * obj1 = 0 ;
14701 PyObject * obj2 = 0 ;
14702 char * kwnames[] = {
14703 (char *) "r",(char *) "g",(char *) "b", NULL
14704 };
14705
14706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14707 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14708 if (!SWIG_IsOK(ecode1)) {
14709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14710 }
14711 arg1 = static_cast< byte >(val1);
14712 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14713 if (!SWIG_IsOK(ecode2)) {
14714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14715 }
14716 arg2 = static_cast< byte >(val2);
14717 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14718 if (!SWIG_IsOK(ecode3)) {
14719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14720 }
14721 arg3 = static_cast< byte >(val3);
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14738 byte *arg2 = (byte *) 0 ;
14739 byte *arg3 = (byte *) 0 ;
14740 byte *arg4 = (byte *) 0 ;
14741 byte arg5 = (byte) 1 ;
14742 byte arg6 = (byte) 0 ;
14743 byte arg7 = (byte) 0 ;
14744 bool result;
14745 void *argp1 = 0 ;
14746 int res1 = 0 ;
14747 byte temp2 ;
14748 int res2 = SWIG_TMPOBJ ;
14749 byte temp3 ;
14750 int res3 = SWIG_TMPOBJ ;
14751 byte temp4 ;
14752 int res4 = SWIG_TMPOBJ ;
14753 unsigned char val5 ;
14754 int ecode5 = 0 ;
14755 unsigned char val6 ;
14756 int ecode6 = 0 ;
14757 unsigned char val7 ;
14758 int ecode7 = 0 ;
14759 PyObject * obj0 = 0 ;
14760 PyObject * obj1 = 0 ;
14761 PyObject * obj2 = 0 ;
14762 PyObject * obj3 = 0 ;
14763 char * kwnames[] = {
14764 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14765 };
14766
14767 arg2 = &temp2;
14768 arg3 = &temp3;
14769 arg4 = &temp4;
14770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14774 }
14775 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14776 if (obj1) {
14777 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14778 if (!SWIG_IsOK(ecode5)) {
14779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14780 }
14781 arg5 = static_cast< byte >(val5);
14782 }
14783 if (obj2) {
14784 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14785 if (!SWIG_IsOK(ecode6)) {
14786 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14787 }
14788 arg6 = static_cast< byte >(val6);
14789 }
14790 if (obj3) {
14791 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14792 if (!SWIG_IsOK(ecode7)) {
14793 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14794 }
14795 arg7 = static_cast< byte >(val7);
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 {
14804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14805 }
14806 if (SWIG_IsTmpObj(res2)) {
14807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14808 } else {
14809 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14811 }
14812 if (SWIG_IsTmpObj(res3)) {
14813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14814 } else {
14815 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14817 }
14818 if (SWIG_IsTmpObj(res4)) {
14819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14820 } else {
14821 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14823 }
14824 return resultobj;
14825 fail:
14826 return NULL;
14827 }
14828
14829
14830 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14831 PyObject *resultobj = 0;
14832 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14833 unsigned long arg2 ;
14834 unsigned long result;
14835 void *argp1 = 0 ;
14836 int res1 = 0 ;
14837 unsigned long val2 ;
14838 int ecode2 = 0 ;
14839 PyObject * obj0 = 0 ;
14840 PyObject * obj1 = 0 ;
14841 char * kwnames[] = {
14842 (char *) "self",(char *) "key", NULL
14843 };
14844
14845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14847 if (!SWIG_IsOK(res1)) {
14848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14849 }
14850 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14851 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14852 if (!SWIG_IsOK(ecode2)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14854 }
14855 arg2 = static_cast< unsigned long >(val2);
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj = 0;
14871 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14872 byte arg2 ;
14873 byte arg3 ;
14874 byte arg4 ;
14875 unsigned long result;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 unsigned char val2 ;
14879 int ecode2 = 0 ;
14880 unsigned char val3 ;
14881 int ecode3 = 0 ;
14882 unsigned char val4 ;
14883 int ecode4 = 0 ;
14884 PyObject * obj0 = 0 ;
14885 PyObject * obj1 = 0 ;
14886 PyObject * obj2 = 0 ;
14887 PyObject * obj3 = 0 ;
14888 char * kwnames[] = {
14889 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14890 };
14891
14892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14894 if (!SWIG_IsOK(res1)) {
14895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14896 }
14897 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14898 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14899 if (!SWIG_IsOK(ecode2)) {
14900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14901 }
14902 arg2 = static_cast< byte >(val2);
14903 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14904 if (!SWIG_IsOK(ecode3)) {
14905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14906 }
14907 arg3 = static_cast< byte >(val3);
14908 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14909 if (!SWIG_IsOK(ecode4)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14911 }
14912 arg4 = static_cast< byte >(val4);
14913 {
14914 PyThreadState* __tstate = wxPyBeginAllowThreads();
14915 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14920 return resultobj;
14921 fail:
14922 return NULL;
14923 }
14924
14925
14926 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14927 PyObject *resultobj = 0;
14928 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14929 wxColour *arg2 = 0 ;
14930 unsigned long result;
14931 void *argp1 = 0 ;
14932 int res1 = 0 ;
14933 wxColour temp2 ;
14934 PyObject * obj0 = 0 ;
14935 PyObject * obj1 = 0 ;
14936 char * kwnames[] = {
14937 (char *) "self",(char *) "colour", NULL
14938 };
14939
14940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14944 }
14945 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14946 {
14947 arg2 = &temp2;
14948 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14949 }
14950 {
14951 PyThreadState* __tstate = wxPyBeginAllowThreads();
14952 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *obj;
14965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14966 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
14967 return SWIG_Py_Void();
14968 }
14969
14970 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14971 return SWIG_Python_InitShadowInstance(args);
14972 }
14973
14974 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 byte arg1 = (byte) 0 ;
14977 byte arg2 = (byte) 0 ;
14978 byte arg3 = (byte) 0 ;
14979 wxImage_RGBValue *result = 0 ;
14980 unsigned char val1 ;
14981 int ecode1 = 0 ;
14982 unsigned char val2 ;
14983 int ecode2 = 0 ;
14984 unsigned char val3 ;
14985 int ecode3 = 0 ;
14986 PyObject * obj0 = 0 ;
14987 PyObject * obj1 = 0 ;
14988 PyObject * obj2 = 0 ;
14989 char * kwnames[] = {
14990 (char *) "r",(char *) "g",(char *) "b", NULL
14991 };
14992
14993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14994 if (obj0) {
14995 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14996 if (!SWIG_IsOK(ecode1)) {
14997 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
14998 }
14999 arg1 = static_cast< byte >(val1);
15000 }
15001 if (obj1) {
15002 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15003 if (!SWIG_IsOK(ecode2)) {
15004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15005 }
15006 arg2 = static_cast< byte >(val2);
15007 }
15008 if (obj2) {
15009 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15010 if (!SWIG_IsOK(ecode3)) {
15011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15012 }
15013 arg3 = static_cast< byte >(val3);
15014 }
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15029 PyObject *resultobj = 0;
15030 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15031 byte arg2 ;
15032 void *argp1 = 0 ;
15033 int res1 = 0 ;
15034 unsigned char val2 ;
15035 int ecode2 = 0 ;
15036 PyObject *swig_obj[2] ;
15037
15038 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15040 if (!SWIG_IsOK(res1)) {
15041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15042 }
15043 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15044 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15045 if (!SWIG_IsOK(ecode2)) {
15046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15047 }
15048 arg2 = static_cast< byte >(val2);
15049 if (arg1) (arg1)->red = arg2;
15050
15051 resultobj = SWIG_Py_Void();
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059 PyObject *resultobj = 0;
15060 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15061 byte result;
15062 void *argp1 = 0 ;
15063 int res1 = 0 ;
15064 PyObject *swig_obj[1] ;
15065
15066 if (!args) SWIG_fail;
15067 swig_obj[0] = args;
15068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15069 if (!SWIG_IsOK(res1)) {
15070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15071 }
15072 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15073 result = (byte) ((arg1)->red);
15074 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15082 PyObject *resultobj = 0;
15083 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15084 byte arg2 ;
15085 void *argp1 = 0 ;
15086 int res1 = 0 ;
15087 unsigned char val2 ;
15088 int ecode2 = 0 ;
15089 PyObject *swig_obj[2] ;
15090
15091 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15093 if (!SWIG_IsOK(res1)) {
15094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15095 }
15096 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15097 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15098 if (!SWIG_IsOK(ecode2)) {
15099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15100 }
15101 arg2 = static_cast< byte >(val2);
15102 if (arg1) (arg1)->green = arg2;
15103
15104 resultobj = SWIG_Py_Void();
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15112 PyObject *resultobj = 0;
15113 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15114 byte result;
15115 void *argp1 = 0 ;
15116 int res1 = 0 ;
15117 PyObject *swig_obj[1] ;
15118
15119 if (!args) SWIG_fail;
15120 swig_obj[0] = args;
15121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15122 if (!SWIG_IsOK(res1)) {
15123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15124 }
15125 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15126 result = (byte) ((arg1)->green);
15127 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15128 return resultobj;
15129 fail:
15130 return NULL;
15131 }
15132
15133
15134 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15135 PyObject *resultobj = 0;
15136 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15137 byte arg2 ;
15138 void *argp1 = 0 ;
15139 int res1 = 0 ;
15140 unsigned char val2 ;
15141 int ecode2 = 0 ;
15142 PyObject *swig_obj[2] ;
15143
15144 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15146 if (!SWIG_IsOK(res1)) {
15147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15148 }
15149 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15150 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15151 if (!SWIG_IsOK(ecode2)) {
15152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15153 }
15154 arg2 = static_cast< byte >(val2);
15155 if (arg1) (arg1)->blue = arg2;
15156
15157 resultobj = SWIG_Py_Void();
15158 return resultobj;
15159 fail:
15160 return NULL;
15161 }
15162
15163
15164 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15165 PyObject *resultobj = 0;
15166 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15167 byte result;
15168 void *argp1 = 0 ;
15169 int res1 = 0 ;
15170 PyObject *swig_obj[1] ;
15171
15172 if (!args) SWIG_fail;
15173 swig_obj[0] = args;
15174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15175 if (!SWIG_IsOK(res1)) {
15176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15177 }
15178 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15179 result = (byte) ((arg1)->blue);
15180 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *obj;
15189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15190 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15191 return SWIG_Py_Void();
15192 }
15193
15194 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 return SWIG_Python_InitShadowInstance(args);
15196 }
15197
15198 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj = 0;
15200 double arg1 = (double) 0.0 ;
15201 double arg2 = (double) 0.0 ;
15202 double arg3 = (double) 0.0 ;
15203 wxImage_HSVValue *result = 0 ;
15204 double val1 ;
15205 int ecode1 = 0 ;
15206 double val2 ;
15207 int ecode2 = 0 ;
15208 double val3 ;
15209 int ecode3 = 0 ;
15210 PyObject * obj0 = 0 ;
15211 PyObject * obj1 = 0 ;
15212 PyObject * obj2 = 0 ;
15213 char * kwnames[] = {
15214 (char *) "h",(char *) "s",(char *) "v", NULL
15215 };
15216
15217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15218 if (obj0) {
15219 ecode1 = SWIG_AsVal_double(obj0, &val1);
15220 if (!SWIG_IsOK(ecode1)) {
15221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15222 }
15223 arg1 = static_cast< double >(val1);
15224 }
15225 if (obj1) {
15226 ecode2 = SWIG_AsVal_double(obj1, &val2);
15227 if (!SWIG_IsOK(ecode2)) {
15228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15229 }
15230 arg2 = static_cast< double >(val2);
15231 }
15232 if (obj2) {
15233 ecode3 = SWIG_AsVal_double(obj2, &val3);
15234 if (!SWIG_IsOK(ecode3)) {
15235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15236 }
15237 arg3 = static_cast< double >(val3);
15238 }
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15253 PyObject *resultobj = 0;
15254 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15255 double arg2 ;
15256 void *argp1 = 0 ;
15257 int res1 = 0 ;
15258 double val2 ;
15259 int ecode2 = 0 ;
15260 PyObject *swig_obj[2] ;
15261
15262 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15264 if (!SWIG_IsOK(res1)) {
15265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15266 }
15267 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15268 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15269 if (!SWIG_IsOK(ecode2)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15271 }
15272 arg2 = static_cast< double >(val2);
15273 if (arg1) (arg1)->hue = arg2;
15274
15275 resultobj = SWIG_Py_Void();
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15283 PyObject *resultobj = 0;
15284 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15285 double result;
15286 void *argp1 = 0 ;
15287 int res1 = 0 ;
15288 PyObject *swig_obj[1] ;
15289
15290 if (!args) SWIG_fail;
15291 swig_obj[0] = args;
15292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15293 if (!SWIG_IsOK(res1)) {
15294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15295 }
15296 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15297 result = (double) ((arg1)->hue);
15298 resultobj = SWIG_From_double(static_cast< double >(result));
15299 return resultobj;
15300 fail:
15301 return NULL;
15302 }
15303
15304
15305 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15306 PyObject *resultobj = 0;
15307 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15308 double arg2 ;
15309 void *argp1 = 0 ;
15310 int res1 = 0 ;
15311 double val2 ;
15312 int ecode2 = 0 ;
15313 PyObject *swig_obj[2] ;
15314
15315 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15317 if (!SWIG_IsOK(res1)) {
15318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15319 }
15320 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15321 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15322 if (!SWIG_IsOK(ecode2)) {
15323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15324 }
15325 arg2 = static_cast< double >(val2);
15326 if (arg1) (arg1)->saturation = arg2;
15327
15328 resultobj = SWIG_Py_Void();
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15336 PyObject *resultobj = 0;
15337 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15338 double result;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 PyObject *swig_obj[1] ;
15342
15343 if (!args) SWIG_fail;
15344 swig_obj[0] = args;
15345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15348 }
15349 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15350 result = (double) ((arg1)->saturation);
15351 resultobj = SWIG_From_double(static_cast< double >(result));
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15359 PyObject *resultobj = 0;
15360 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15361 double arg2 ;
15362 void *argp1 = 0 ;
15363 int res1 = 0 ;
15364 double val2 ;
15365 int ecode2 = 0 ;
15366 PyObject *swig_obj[2] ;
15367
15368 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15370 if (!SWIG_IsOK(res1)) {
15371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15372 }
15373 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15374 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15375 if (!SWIG_IsOK(ecode2)) {
15376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15377 }
15378 arg2 = static_cast< double >(val2);
15379 if (arg1) (arg1)->value = arg2;
15380
15381 resultobj = SWIG_Py_Void();
15382 return resultobj;
15383 fail:
15384 return NULL;
15385 }
15386
15387
15388 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15389 PyObject *resultobj = 0;
15390 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15391 double result;
15392 void *argp1 = 0 ;
15393 int res1 = 0 ;
15394 PyObject *swig_obj[1] ;
15395
15396 if (!args) SWIG_fail;
15397 swig_obj[0] = args;
15398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15399 if (!SWIG_IsOK(res1)) {
15400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15401 }
15402 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15403 result = (double) ((arg1)->value);
15404 resultobj = SWIG_From_double(static_cast< double >(result));
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15412 PyObject *obj;
15413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15414 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15415 return SWIG_Py_Void();
15416 }
15417
15418 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15419 return SWIG_Python_InitShadowInstance(args);
15420 }
15421
15422 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15423 PyObject *resultobj = 0;
15424 wxString *arg1 = 0 ;
15425 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15426 int arg3 = (int) -1 ;
15427 wxImage *result = 0 ;
15428 bool temp1 = false ;
15429 long val2 ;
15430 int ecode2 = 0 ;
15431 int val3 ;
15432 int ecode3 = 0 ;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 PyObject * obj2 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "name",(char *) "type",(char *) "index", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15441 {
15442 arg1 = wxString_in_helper(obj0);
15443 if (arg1 == NULL) SWIG_fail;
15444 temp1 = true;
15445 }
15446 if (obj1) {
15447 ecode2 = SWIG_AsVal_long(obj1, &val2);
15448 if (!SWIG_IsOK(ecode2)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15450 }
15451 arg2 = static_cast< long >(val2);
15452 }
15453 if (obj2) {
15454 ecode3 = SWIG_AsVal_int(obj2, &val3);
15455 if (!SWIG_IsOK(ecode3)) {
15456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15457 }
15458 arg3 = static_cast< int >(val3);
15459 }
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15463 wxPyEndAllowThreads(__tstate);
15464 if (PyErr_Occurred()) SWIG_fail;
15465 }
15466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15467 {
15468 if (temp1)
15469 delete arg1;
15470 }
15471 return resultobj;
15472 fail:
15473 {
15474 if (temp1)
15475 delete arg1;
15476 }
15477 return NULL;
15478 }
15479
15480
15481 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15482 PyObject *resultobj = 0;
15483 wxImage *arg1 = (wxImage *) 0 ;
15484 void *argp1 = 0 ;
15485 int res1 = 0 ;
15486 PyObject *swig_obj[1] ;
15487
15488 if (!args) SWIG_fail;
15489 swig_obj[0] = args;
15490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15491 if (!SWIG_IsOK(res1)) {
15492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15493 }
15494 arg1 = reinterpret_cast< wxImage * >(argp1);
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 delete arg1;
15498
15499 wxPyEndAllowThreads(__tstate);
15500 if (PyErr_Occurred()) SWIG_fail;
15501 }
15502 resultobj = SWIG_Py_Void();
15503 return resultobj;
15504 fail:
15505 return NULL;
15506 }
15507
15508
15509 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15510 PyObject *resultobj = 0;
15511 wxString *arg1 = 0 ;
15512 wxString *arg2 = 0 ;
15513 int arg3 = (int) -1 ;
15514 wxImage *result = 0 ;
15515 bool temp1 = false ;
15516 bool temp2 = false ;
15517 int val3 ;
15518 int ecode3 = 0 ;
15519 PyObject * obj0 = 0 ;
15520 PyObject * obj1 = 0 ;
15521 PyObject * obj2 = 0 ;
15522 char * kwnames[] = {
15523 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15524 };
15525
15526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15527 {
15528 arg1 = wxString_in_helper(obj0);
15529 if (arg1 == NULL) SWIG_fail;
15530 temp1 = true;
15531 }
15532 {
15533 arg2 = wxString_in_helper(obj1);
15534 if (arg2 == NULL) SWIG_fail;
15535 temp2 = true;
15536 }
15537 if (obj2) {
15538 ecode3 = SWIG_AsVal_int(obj2, &val3);
15539 if (!SWIG_IsOK(ecode3)) {
15540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15541 }
15542 arg3 = static_cast< int >(val3);
15543 }
15544 {
15545 PyThreadState* __tstate = wxPyBeginAllowThreads();
15546 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15551 {
15552 if (temp1)
15553 delete arg1;
15554 }
15555 {
15556 if (temp2)
15557 delete arg2;
15558 }
15559 return resultobj;
15560 fail:
15561 {
15562 if (temp1)
15563 delete arg1;
15564 }
15565 {
15566 if (temp2)
15567 delete arg2;
15568 }
15569 return NULL;
15570 }
15571
15572
15573 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = 0;
15575 wxInputStream *arg1 = 0 ;
15576 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15577 int arg3 = (int) -1 ;
15578 wxImage *result = 0 ;
15579 wxPyInputStream *temp1 ;
15580 bool created1 ;
15581 long val2 ;
15582 int ecode2 = 0 ;
15583 int val3 ;
15584 int ecode3 = 0 ;
15585 PyObject * obj0 = 0 ;
15586 PyObject * obj1 = 0 ;
15587 PyObject * obj2 = 0 ;
15588 char * kwnames[] = {
15589 (char *) "stream",(char *) "type",(char *) "index", NULL
15590 };
15591
15592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15593 {
15594 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15595 arg1 = temp1->m_wxis;
15596 created1 = false;
15597 } else {
15598 PyErr_Clear(); // clear the failure of the wxPyConvert above
15599 arg1 = wxPyCBInputStream_create(obj0, false);
15600 if (arg1 == NULL) {
15601 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15602 SWIG_fail;
15603 }
15604 created1 = true;
15605 }
15606 }
15607 if (obj1) {
15608 ecode2 = SWIG_AsVal_long(obj1, &val2);
15609 if (!SWIG_IsOK(ecode2)) {
15610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15611 }
15612 arg2 = static_cast< long >(val2);
15613 }
15614 if (obj2) {
15615 ecode3 = SWIG_AsVal_int(obj2, &val3);
15616 if (!SWIG_IsOK(ecode3)) {
15617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15618 }
15619 arg3 = static_cast< int >(val3);
15620 }
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15624 wxPyEndAllowThreads(__tstate);
15625 if (PyErr_Occurred()) SWIG_fail;
15626 }
15627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15628 {
15629 if (created1) delete arg1;
15630 }
15631 return resultobj;
15632 fail:
15633 {
15634 if (created1) delete arg1;
15635 }
15636 return NULL;
15637 }
15638
15639
15640 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15641 PyObject *resultobj = 0;
15642 wxInputStream *arg1 = 0 ;
15643 wxString *arg2 = 0 ;
15644 int arg3 = (int) -1 ;
15645 wxImage *result = 0 ;
15646 wxPyInputStream *temp1 ;
15647 bool created1 ;
15648 bool temp2 = false ;
15649 int val3 ;
15650 int ecode3 = 0 ;
15651 PyObject * obj0 = 0 ;
15652 PyObject * obj1 = 0 ;
15653 PyObject * obj2 = 0 ;
15654 char * kwnames[] = {
15655 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15656 };
15657
15658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15659 {
15660 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15661 arg1 = temp1->m_wxis;
15662 created1 = false;
15663 } else {
15664 PyErr_Clear(); // clear the failure of the wxPyConvert above
15665 arg1 = wxPyCBInputStream_create(obj0, false);
15666 if (arg1 == NULL) {
15667 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15668 SWIG_fail;
15669 }
15670 created1 = true;
15671 }
15672 }
15673 {
15674 arg2 = wxString_in_helper(obj1);
15675 if (arg2 == NULL) SWIG_fail;
15676 temp2 = true;
15677 }
15678 if (obj2) {
15679 ecode3 = SWIG_AsVal_int(obj2, &val3);
15680 if (!SWIG_IsOK(ecode3)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15682 }
15683 arg3 = static_cast< int >(val3);
15684 }
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15692 {
15693 if (created1) delete arg1;
15694 }
15695 {
15696 if (temp2)
15697 delete arg2;
15698 }
15699 return resultobj;
15700 fail:
15701 {
15702 if (created1) delete arg1;
15703 }
15704 {
15705 if (temp2)
15706 delete arg2;
15707 }
15708 return NULL;
15709 }
15710
15711
15712 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15713 PyObject *resultobj = 0;
15714 int arg1 = (int) 0 ;
15715 int arg2 = (int) 0 ;
15716 bool arg3 = (bool) true ;
15717 wxImage *result = 0 ;
15718 int val1 ;
15719 int ecode1 = 0 ;
15720 int val2 ;
15721 int ecode2 = 0 ;
15722 bool val3 ;
15723 int ecode3 = 0 ;
15724 PyObject * obj0 = 0 ;
15725 PyObject * obj1 = 0 ;
15726 PyObject * obj2 = 0 ;
15727 char * kwnames[] = {
15728 (char *) "width",(char *) "height",(char *) "clear", NULL
15729 };
15730
15731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15732 if (obj0) {
15733 ecode1 = SWIG_AsVal_int(obj0, &val1);
15734 if (!SWIG_IsOK(ecode1)) {
15735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15736 }
15737 arg1 = static_cast< int >(val1);
15738 }
15739 if (obj1) {
15740 ecode2 = SWIG_AsVal_int(obj1, &val2);
15741 if (!SWIG_IsOK(ecode2)) {
15742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15743 }
15744 arg2 = static_cast< int >(val2);
15745 }
15746 if (obj2) {
15747 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15748 if (!SWIG_IsOK(ecode3)) {
15749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15750 }
15751 arg3 = static_cast< bool >(val3);
15752 }
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15756 wxPyEndAllowThreads(__tstate);
15757 if (PyErr_Occurred()) SWIG_fail;
15758 }
15759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15767 PyObject *resultobj = 0;
15768 wxBitmap *arg1 = 0 ;
15769 wxImage *result = 0 ;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 PyObject * obj0 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "bitmap", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15778 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15781 }
15782 if (!argp1) {
15783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15784 }
15785 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15786 {
15787 if (!wxPyCheckForApp()) SWIG_fail;
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15801 PyObject *resultobj = 0;
15802 int arg1 ;
15803 int arg2 ;
15804 buffer arg3 ;
15805 int arg4 ;
15806 wxImage *result = 0 ;
15807 int val1 ;
15808 int ecode1 = 0 ;
15809 int val2 ;
15810 int ecode2 = 0 ;
15811 Py_ssize_t temp3 ;
15812 PyObject * obj0 = 0 ;
15813 PyObject * obj1 = 0 ;
15814 PyObject * obj2 = 0 ;
15815 char * kwnames[] = {
15816 (char *) "width",(char *) "height",(char *) "data", NULL
15817 };
15818
15819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15820 ecode1 = SWIG_AsVal_int(obj0, &val1);
15821 if (!SWIG_IsOK(ecode1)) {
15822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15823 }
15824 arg1 = static_cast< int >(val1);
15825 ecode2 = SWIG_AsVal_int(obj1, &val2);
15826 if (!SWIG_IsOK(ecode2)) {
15827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15828 }
15829 arg2 = static_cast< int >(val2);
15830 {
15831 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15832 arg4 = (int)temp3;
15833 }
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15841 return resultobj;
15842 fail:
15843 return NULL;
15844 }
15845
15846
15847 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15848 PyObject *resultobj = 0;
15849 int arg1 ;
15850 int arg2 ;
15851 buffer arg3 ;
15852 int arg4 ;
15853 buffer arg5 ;
15854 int arg6 ;
15855 wxImage *result = 0 ;
15856 int val1 ;
15857 int ecode1 = 0 ;
15858 int val2 ;
15859 int ecode2 = 0 ;
15860 Py_ssize_t temp3 ;
15861 Py_ssize_t temp5 ;
15862 PyObject * obj0 = 0 ;
15863 PyObject * obj1 = 0 ;
15864 PyObject * obj2 = 0 ;
15865 PyObject * obj3 = 0 ;
15866 char * kwnames[] = {
15867 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15868 };
15869
15870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15871 ecode1 = SWIG_AsVal_int(obj0, &val1);
15872 if (!SWIG_IsOK(ecode1)) {
15873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15874 }
15875 arg1 = static_cast< int >(val1);
15876 ecode2 = SWIG_AsVal_int(obj1, &val2);
15877 if (!SWIG_IsOK(ecode2)) {
15878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15879 }
15880 arg2 = static_cast< int >(val2);
15881 {
15882 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15883 arg4 = (int)temp3;
15884 }
15885 {
15886 if (obj3 != Py_None) {
15887 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15888 arg6 = (int)temp5;
15889 }
15890 }
15891 {
15892 PyThreadState* __tstate = wxPyBeginAllowThreads();
15893 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15894 wxPyEndAllowThreads(__tstate);
15895 if (PyErr_Occurred()) SWIG_fail;
15896 }
15897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15898 return resultobj;
15899 fail:
15900 return NULL;
15901 }
15902
15903
15904 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15905 PyObject *resultobj = 0;
15906 wxImage *arg1 = (wxImage *) 0 ;
15907 int arg2 ;
15908 int arg3 ;
15909 bool arg4 = (bool) true ;
15910 void *argp1 = 0 ;
15911 int res1 = 0 ;
15912 int val2 ;
15913 int ecode2 = 0 ;
15914 int val3 ;
15915 int ecode3 = 0 ;
15916 bool val4 ;
15917 int ecode4 = 0 ;
15918 PyObject * obj0 = 0 ;
15919 PyObject * obj1 = 0 ;
15920 PyObject * obj2 = 0 ;
15921 PyObject * obj3 = 0 ;
15922 char * kwnames[] = {
15923 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15924 };
15925
15926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15928 if (!SWIG_IsOK(res1)) {
15929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15930 }
15931 arg1 = reinterpret_cast< wxImage * >(argp1);
15932 ecode2 = SWIG_AsVal_int(obj1, &val2);
15933 if (!SWIG_IsOK(ecode2)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15935 }
15936 arg2 = static_cast< int >(val2);
15937 ecode3 = SWIG_AsVal_int(obj2, &val3);
15938 if (!SWIG_IsOK(ecode3)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15940 }
15941 arg3 = static_cast< int >(val3);
15942 if (obj3) {
15943 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15944 if (!SWIG_IsOK(ecode4)) {
15945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15946 }
15947 arg4 = static_cast< bool >(val4);
15948 }
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 (arg1)->Create(arg2,arg3,arg4);
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_Py_Void();
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15963 PyObject *resultobj = 0;
15964 wxImage *arg1 = (wxImage *) 0 ;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
15974 }
15975 arg1 = reinterpret_cast< wxImage * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 (arg1)->Destroy();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_Py_Void();
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15990 PyObject *resultobj = 0;
15991 wxImage *arg1 = (wxImage *) 0 ;
15992 int arg2 ;
15993 int arg3 ;
15994 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
15995 SwigValueWrapper<wxImage > result;
15996 void *argp1 = 0 ;
15997 int res1 = 0 ;
15998 int val2 ;
15999 int ecode2 = 0 ;
16000 int val3 ;
16001 int ecode3 = 0 ;
16002 int val4 ;
16003 int ecode4 = 0 ;
16004 PyObject * obj0 = 0 ;
16005 PyObject * obj1 = 0 ;
16006 PyObject * obj2 = 0 ;
16007 PyObject * obj3 = 0 ;
16008 char * kwnames[] = {
16009 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16010 };
16011
16012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16014 if (!SWIG_IsOK(res1)) {
16015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16016 }
16017 arg1 = reinterpret_cast< wxImage * >(argp1);
16018 ecode2 = SWIG_AsVal_int(obj1, &val2);
16019 if (!SWIG_IsOK(ecode2)) {
16020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16021 }
16022 arg2 = static_cast< int >(val2);
16023 ecode3 = SWIG_AsVal_int(obj2, &val3);
16024 if (!SWIG_IsOK(ecode3)) {
16025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16026 }
16027 arg3 = static_cast< int >(val3);
16028 if (obj3) {
16029 ecode4 = SWIG_AsVal_int(obj3, &val4);
16030 if (!SWIG_IsOK(ecode4)) {
16031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16032 }
16033 arg4 = static_cast< int >(val4);
16034 }
16035 {
16036 PyThreadState* __tstate = wxPyBeginAllowThreads();
16037 result = (arg1)->Scale(arg2,arg3,arg4);
16038 wxPyEndAllowThreads(__tstate);
16039 if (PyErr_Occurred()) SWIG_fail;
16040 }
16041 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16042 return resultobj;
16043 fail:
16044 return NULL;
16045 }
16046
16047
16048 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16049 PyObject *resultobj = 0;
16050 wxImage *arg1 = (wxImage *) 0 ;
16051 int arg2 ;
16052 int arg3 ;
16053 SwigValueWrapper<wxImage > result;
16054 void *argp1 = 0 ;
16055 int res1 = 0 ;
16056 int val2 ;
16057 int ecode2 = 0 ;
16058 int val3 ;
16059 int ecode3 = 0 ;
16060 PyObject * obj0 = 0 ;
16061 PyObject * obj1 = 0 ;
16062 PyObject * obj2 = 0 ;
16063 char * kwnames[] = {
16064 (char *) "self",(char *) "width",(char *) "height", NULL
16065 };
16066
16067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16069 if (!SWIG_IsOK(res1)) {
16070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16071 }
16072 arg1 = reinterpret_cast< wxImage * >(argp1);
16073 ecode2 = SWIG_AsVal_int(obj1, &val2);
16074 if (!SWIG_IsOK(ecode2)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16076 }
16077 arg2 = static_cast< int >(val2);
16078 ecode3 = SWIG_AsVal_int(obj2, &val3);
16079 if (!SWIG_IsOK(ecode3)) {
16080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16081 }
16082 arg3 = static_cast< int >(val3);
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16097 PyObject *resultobj = 0;
16098 wxImage *arg1 = (wxImage *) 0 ;
16099 int arg2 ;
16100 int arg3 ;
16101 SwigValueWrapper<wxImage > result;
16102 void *argp1 = 0 ;
16103 int res1 = 0 ;
16104 int val2 ;
16105 int ecode2 = 0 ;
16106 int val3 ;
16107 int ecode3 = 0 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 PyObject * obj2 = 0 ;
16111 char * kwnames[] = {
16112 (char *) "self",(char *) "width",(char *) "height", NULL
16113 };
16114
16115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16117 if (!SWIG_IsOK(res1)) {
16118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16119 }
16120 arg1 = reinterpret_cast< wxImage * >(argp1);
16121 ecode2 = SWIG_AsVal_int(obj1, &val2);
16122 if (!SWIG_IsOK(ecode2)) {
16123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16124 }
16125 arg2 = static_cast< int >(val2);
16126 ecode3 = SWIG_AsVal_int(obj2, &val3);
16127 if (!SWIG_IsOK(ecode3)) {
16128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16129 }
16130 arg3 = static_cast< int >(val3);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16138 return resultobj;
16139 fail:
16140 return NULL;
16141 }
16142
16143
16144 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj = 0;
16146 wxImage *arg1 = (wxImage *) 0 ;
16147 int arg2 ;
16148 SwigValueWrapper<wxImage > result;
16149 void *argp1 = 0 ;
16150 int res1 = 0 ;
16151 int val2 ;
16152 int ecode2 = 0 ;
16153 PyObject * obj0 = 0 ;
16154 PyObject * obj1 = 0 ;
16155 char * kwnames[] = {
16156 (char *) "self",(char *) "radius", NULL
16157 };
16158
16159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16163 }
16164 arg1 = reinterpret_cast< wxImage * >(argp1);
16165 ecode2 = SWIG_AsVal_int(obj1, &val2);
16166 if (!SWIG_IsOK(ecode2)) {
16167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16168 }
16169 arg2 = static_cast< int >(val2);
16170 {
16171 PyThreadState* __tstate = wxPyBeginAllowThreads();
16172 result = (arg1)->Blur(arg2);
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj = 0;
16185 wxImage *arg1 = (wxImage *) 0 ;
16186 int arg2 ;
16187 SwigValueWrapper<wxImage > result;
16188 void *argp1 = 0 ;
16189 int res1 = 0 ;
16190 int val2 ;
16191 int ecode2 = 0 ;
16192 PyObject * obj0 = 0 ;
16193 PyObject * obj1 = 0 ;
16194 char * kwnames[] = {
16195 (char *) "self",(char *) "radius", NULL
16196 };
16197
16198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16200 if (!SWIG_IsOK(res1)) {
16201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16202 }
16203 arg1 = reinterpret_cast< wxImage * >(argp1);
16204 ecode2 = SWIG_AsVal_int(obj1, &val2);
16205 if (!SWIG_IsOK(ecode2)) {
16206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16207 }
16208 arg2 = static_cast< int >(val2);
16209 {
16210 PyThreadState* __tstate = wxPyBeginAllowThreads();
16211 result = (arg1)->BlurHorizontal(arg2);
16212 wxPyEndAllowThreads(__tstate);
16213 if (PyErr_Occurred()) SWIG_fail;
16214 }
16215 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16223 PyObject *resultobj = 0;
16224 wxImage *arg1 = (wxImage *) 0 ;
16225 int arg2 ;
16226 SwigValueWrapper<wxImage > result;
16227 void *argp1 = 0 ;
16228 int res1 = 0 ;
16229 int val2 ;
16230 int ecode2 = 0 ;
16231 PyObject * obj0 = 0 ;
16232 PyObject * obj1 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "radius", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 ecode2 = SWIG_AsVal_int(obj1, &val2);
16244 if (!SWIG_IsOK(ecode2)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16246 }
16247 arg2 = static_cast< int >(val2);
16248 {
16249 PyThreadState* __tstate = wxPyBeginAllowThreads();
16250 result = (arg1)->BlurVertical(arg2);
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj = 0;
16263 wxImage *arg1 = (wxImage *) 0 ;
16264 int arg2 ;
16265 int arg3 ;
16266 SwigValueWrapper<wxImage > result;
16267 void *argp1 = 0 ;
16268 int res1 = 0 ;
16269 int val2 ;
16270 int ecode2 = 0 ;
16271 int val3 ;
16272 int ecode3 = 0 ;
16273 PyObject * obj0 = 0 ;
16274 PyObject * obj1 = 0 ;
16275 PyObject * obj2 = 0 ;
16276 char * kwnames[] = {
16277 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16278 };
16279
16280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16282 if (!SWIG_IsOK(res1)) {
16283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16284 }
16285 arg1 = reinterpret_cast< wxImage * >(argp1);
16286 ecode2 = SWIG_AsVal_int(obj1, &val2);
16287 if (!SWIG_IsOK(ecode2)) {
16288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16289 }
16290 arg2 = static_cast< int >(val2);
16291 ecode3 = SWIG_AsVal_int(obj2, &val3);
16292 if (!SWIG_IsOK(ecode3)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16294 }
16295 arg3 = static_cast< int >(val3);
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = 0;
16311 wxImage *arg1 = (wxImage *) 0 ;
16312 int arg2 ;
16313 int arg3 ;
16314 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16315 wxImage *result = 0 ;
16316 void *argp1 = 0 ;
16317 int res1 = 0 ;
16318 int val2 ;
16319 int ecode2 = 0 ;
16320 int val3 ;
16321 int ecode3 = 0 ;
16322 int val4 ;
16323 int ecode4 = 0 ;
16324 PyObject * obj0 = 0 ;
16325 PyObject * obj1 = 0 ;
16326 PyObject * obj2 = 0 ;
16327 PyObject * obj3 = 0 ;
16328 char * kwnames[] = {
16329 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16330 };
16331
16332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16336 }
16337 arg1 = reinterpret_cast< wxImage * >(argp1);
16338 ecode2 = SWIG_AsVal_int(obj1, &val2);
16339 if (!SWIG_IsOK(ecode2)) {
16340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16341 }
16342 arg2 = static_cast< int >(val2);
16343 ecode3 = SWIG_AsVal_int(obj2, &val3);
16344 if (!SWIG_IsOK(ecode3)) {
16345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16346 }
16347 arg3 = static_cast< int >(val3);
16348 if (obj3) {
16349 ecode4 = SWIG_AsVal_int(obj3, &val4);
16350 if (!SWIG_IsOK(ecode4)) {
16351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16352 }
16353 arg4 = static_cast< int >(val4);
16354 }
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 {
16358 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16359 result = (wxImage *) &_result_ref;
16360 }
16361 wxPyEndAllowThreads(__tstate);
16362 if (PyErr_Occurred()) SWIG_fail;
16363 }
16364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16365 return resultobj;
16366 fail:
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 wxSize *arg2 = 0 ;
16375 wxPoint *arg3 = 0 ;
16376 int arg4 = (int) -1 ;
16377 int arg5 = (int) -1 ;
16378 int arg6 = (int) -1 ;
16379 wxImage *result = 0 ;
16380 void *argp1 = 0 ;
16381 int res1 = 0 ;
16382 wxSize temp2 ;
16383 wxPoint temp3 ;
16384 int val4 ;
16385 int ecode4 = 0 ;
16386 int val5 ;
16387 int ecode5 = 0 ;
16388 int val6 ;
16389 int ecode6 = 0 ;
16390 PyObject * obj0 = 0 ;
16391 PyObject * obj1 = 0 ;
16392 PyObject * obj2 = 0 ;
16393 PyObject * obj3 = 0 ;
16394 PyObject * obj4 = 0 ;
16395 PyObject * obj5 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16404 }
16405 arg1 = reinterpret_cast< wxImage * >(argp1);
16406 {
16407 arg2 = &temp2;
16408 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16409 }
16410 {
16411 arg3 = &temp3;
16412 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16413 }
16414 if (obj3) {
16415 ecode4 = SWIG_AsVal_int(obj3, &val4);
16416 if (!SWIG_IsOK(ecode4)) {
16417 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16418 }
16419 arg4 = static_cast< int >(val4);
16420 }
16421 if (obj4) {
16422 ecode5 = SWIG_AsVal_int(obj4, &val5);
16423 if (!SWIG_IsOK(ecode5)) {
16424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16425 }
16426 arg5 = static_cast< int >(val5);
16427 }
16428 if (obj5) {
16429 ecode6 = SWIG_AsVal_int(obj5, &val6);
16430 if (!SWIG_IsOK(ecode6)) {
16431 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16432 }
16433 arg6 = static_cast< int >(val6);
16434 }
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 {
16438 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16439 result = (wxImage *) &_result_ref;
16440 }
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxImage *arg1 = (wxImage *) 0 ;
16454 int arg2 ;
16455 int arg3 ;
16456 byte arg4 ;
16457 byte arg5 ;
16458 byte arg6 ;
16459 void *argp1 = 0 ;
16460 int res1 = 0 ;
16461 int val2 ;
16462 int ecode2 = 0 ;
16463 int val3 ;
16464 int ecode3 = 0 ;
16465 unsigned char val4 ;
16466 int ecode4 = 0 ;
16467 unsigned char val5 ;
16468 int ecode5 = 0 ;
16469 unsigned char val6 ;
16470 int ecode6 = 0 ;
16471 PyObject * obj0 = 0 ;
16472 PyObject * obj1 = 0 ;
16473 PyObject * obj2 = 0 ;
16474 PyObject * obj3 = 0 ;
16475 PyObject * obj4 = 0 ;
16476 PyObject * obj5 = 0 ;
16477 char * kwnames[] = {
16478 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16479 };
16480
16481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16483 if (!SWIG_IsOK(res1)) {
16484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16485 }
16486 arg1 = reinterpret_cast< wxImage * >(argp1);
16487 ecode2 = SWIG_AsVal_int(obj1, &val2);
16488 if (!SWIG_IsOK(ecode2)) {
16489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16490 }
16491 arg2 = static_cast< int >(val2);
16492 ecode3 = SWIG_AsVal_int(obj2, &val3);
16493 if (!SWIG_IsOK(ecode3)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16495 }
16496 arg3 = static_cast< int >(val3);
16497 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16498 if (!SWIG_IsOK(ecode4)) {
16499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16500 }
16501 arg4 = static_cast< byte >(val4);
16502 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16503 if (!SWIG_IsOK(ecode5)) {
16504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16505 }
16506 arg5 = static_cast< byte >(val5);
16507 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16508 if (!SWIG_IsOK(ecode6)) {
16509 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16510 }
16511 arg6 = static_cast< byte >(val6);
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = SWIG_Py_Void();
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxImage *arg1 = (wxImage *) 0 ;
16528 wxRect *arg2 = 0 ;
16529 byte arg3 ;
16530 byte arg4 ;
16531 byte arg5 ;
16532 void *argp1 = 0 ;
16533 int res1 = 0 ;
16534 wxRect temp2 ;
16535 unsigned char val3 ;
16536 int ecode3 = 0 ;
16537 unsigned char val4 ;
16538 int ecode4 = 0 ;
16539 unsigned char val5 ;
16540 int ecode5 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 PyObject * obj2 = 0 ;
16544 PyObject * obj3 = 0 ;
16545 PyObject * obj4 = 0 ;
16546 char * kwnames[] = {
16547 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16548 };
16549
16550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16552 if (!SWIG_IsOK(res1)) {
16553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16554 }
16555 arg1 = reinterpret_cast< wxImage * >(argp1);
16556 {
16557 arg2 = &temp2;
16558 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16559 }
16560 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16561 if (!SWIG_IsOK(ecode3)) {
16562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16563 }
16564 arg3 = static_cast< byte >(val3);
16565 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16566 if (!SWIG_IsOK(ecode4)) {
16567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16568 }
16569 arg4 = static_cast< byte >(val4);
16570 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16571 if (!SWIG_IsOK(ecode5)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16573 }
16574 arg5 = static_cast< byte >(val5);
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16578 wxPyEndAllowThreads(__tstate);
16579 if (PyErr_Occurred()) SWIG_fail;
16580 }
16581 resultobj = SWIG_Py_Void();
16582 return resultobj;
16583 fail:
16584 return NULL;
16585 }
16586
16587
16588 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16589 PyObject *resultobj = 0;
16590 wxImage *arg1 = (wxImage *) 0 ;
16591 int arg2 ;
16592 int arg3 ;
16593 byte result;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 int val2 ;
16597 int ecode2 = 0 ;
16598 int val3 ;
16599 int ecode3 = 0 ;
16600 PyObject * obj0 = 0 ;
16601 PyObject * obj1 = 0 ;
16602 PyObject * obj2 = 0 ;
16603 char * kwnames[] = {
16604 (char *) "self",(char *) "x",(char *) "y", NULL
16605 };
16606
16607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16609 if (!SWIG_IsOK(res1)) {
16610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16611 }
16612 arg1 = reinterpret_cast< wxImage * >(argp1);
16613 ecode2 = SWIG_AsVal_int(obj1, &val2);
16614 if (!SWIG_IsOK(ecode2)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16616 }
16617 arg2 = static_cast< int >(val2);
16618 ecode3 = SWIG_AsVal_int(obj2, &val3);
16619 if (!SWIG_IsOK(ecode3)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16621 }
16622 arg3 = static_cast< int >(val3);
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = (byte)(arg1)->GetRed(arg2,arg3);
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj = 0;
16638 wxImage *arg1 = (wxImage *) 0 ;
16639 int arg2 ;
16640 int arg3 ;
16641 byte result;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 int val2 ;
16645 int ecode2 = 0 ;
16646 int val3 ;
16647 int ecode3 = 0 ;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 PyObject * obj2 = 0 ;
16651 char * kwnames[] = {
16652 (char *) "self",(char *) "x",(char *) "y", NULL
16653 };
16654
16655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16659 }
16660 arg1 = reinterpret_cast< wxImage * >(argp1);
16661 ecode2 = SWIG_AsVal_int(obj1, &val2);
16662 if (!SWIG_IsOK(ecode2)) {
16663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16664 }
16665 arg2 = static_cast< int >(val2);
16666 ecode3 = SWIG_AsVal_int(obj2, &val3);
16667 if (!SWIG_IsOK(ecode3)) {
16668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16669 }
16670 arg3 = static_cast< int >(val3);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (byte)(arg1)->GetGreen(arg2,arg3);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxImage *arg1 = (wxImage *) 0 ;
16687 int arg2 ;
16688 int arg3 ;
16689 byte result;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 int val2 ;
16693 int ecode2 = 0 ;
16694 int val3 ;
16695 int ecode3 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 char * kwnames[] = {
16700 (char *) "self",(char *) "x",(char *) "y", NULL
16701 };
16702
16703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16707 }
16708 arg1 = reinterpret_cast< wxImage * >(argp1);
16709 ecode2 = SWIG_AsVal_int(obj1, &val2);
16710 if (!SWIG_IsOK(ecode2)) {
16711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16712 }
16713 arg2 = static_cast< int >(val2);
16714 ecode3 = SWIG_AsVal_int(obj2, &val3);
16715 if (!SWIG_IsOK(ecode3)) {
16716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16717 }
16718 arg3 = static_cast< int >(val3);
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (byte)(arg1)->GetBlue(arg2,arg3);
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16726 return resultobj;
16727 fail:
16728 return NULL;
16729 }
16730
16731
16732 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = 0;
16734 wxImage *arg1 = (wxImage *) 0 ;
16735 int arg2 ;
16736 int arg3 ;
16737 byte arg4 ;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 int val2 ;
16741 int ecode2 = 0 ;
16742 int val3 ;
16743 int ecode3 = 0 ;
16744 unsigned char val4 ;
16745 int ecode4 = 0 ;
16746 PyObject * obj0 = 0 ;
16747 PyObject * obj1 = 0 ;
16748 PyObject * obj2 = 0 ;
16749 PyObject * obj3 = 0 ;
16750 char * kwnames[] = {
16751 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16752 };
16753
16754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16756 if (!SWIG_IsOK(res1)) {
16757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16758 }
16759 arg1 = reinterpret_cast< wxImage * >(argp1);
16760 ecode2 = SWIG_AsVal_int(obj1, &val2);
16761 if (!SWIG_IsOK(ecode2)) {
16762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16763 }
16764 arg2 = static_cast< int >(val2);
16765 ecode3 = SWIG_AsVal_int(obj2, &val3);
16766 if (!SWIG_IsOK(ecode3)) {
16767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16768 }
16769 arg3 = static_cast< int >(val3);
16770 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16771 if (!SWIG_IsOK(ecode4)) {
16772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16773 }
16774 arg4 = static_cast< byte >(val4);
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 (arg1)->SetAlpha(arg2,arg3,arg4);
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 resultobj = SWIG_Py_Void();
16782 return resultobj;
16783 fail:
16784 return NULL;
16785 }
16786
16787
16788 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj = 0;
16790 wxImage *arg1 = (wxImage *) 0 ;
16791 int arg2 ;
16792 int arg3 ;
16793 byte result;
16794 void *argp1 = 0 ;
16795 int res1 = 0 ;
16796 int val2 ;
16797 int ecode2 = 0 ;
16798 int val3 ;
16799 int ecode3 = 0 ;
16800 PyObject * obj0 = 0 ;
16801 PyObject * obj1 = 0 ;
16802 PyObject * obj2 = 0 ;
16803 char * kwnames[] = {
16804 (char *) "self",(char *) "x",(char *) "y", NULL
16805 };
16806
16807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16809 if (!SWIG_IsOK(res1)) {
16810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16811 }
16812 arg1 = reinterpret_cast< wxImage * >(argp1);
16813 ecode2 = SWIG_AsVal_int(obj1, &val2);
16814 if (!SWIG_IsOK(ecode2)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16816 }
16817 arg2 = static_cast< int >(val2);
16818 ecode3 = SWIG_AsVal_int(obj2, &val3);
16819 if (!SWIG_IsOK(ecode3)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16821 }
16822 arg3 = static_cast< int >(val3);
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16837 PyObject *resultobj = 0;
16838 wxImage *arg1 = (wxImage *) 0 ;
16839 bool result;
16840 void *argp1 = 0 ;
16841 int res1 = 0 ;
16842 PyObject *swig_obj[1] ;
16843
16844 if (!args) SWIG_fail;
16845 swig_obj[0] = args;
16846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16847 if (!SWIG_IsOK(res1)) {
16848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16849 }
16850 arg1 = reinterpret_cast< wxImage * >(argp1);
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = (bool)(arg1)->HasAlpha();
16854 wxPyEndAllowThreads(__tstate);
16855 if (PyErr_Occurred()) SWIG_fail;
16856 }
16857 {
16858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16859 }
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16867 PyObject *resultobj = 0;
16868 wxImage *arg1 = (wxImage *) 0 ;
16869 void *argp1 = 0 ;
16870 int res1 = 0 ;
16871 PyObject *swig_obj[1] ;
16872
16873 if (!args) SWIG_fail;
16874 swig_obj[0] = args;
16875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16876 if (!SWIG_IsOK(res1)) {
16877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16878 }
16879 arg1 = reinterpret_cast< wxImage * >(argp1);
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 (arg1)->InitAlpha();
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_Py_Void();
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj = 0;
16895 wxImage *arg1 = (wxImage *) 0 ;
16896 int arg2 ;
16897 int arg3 ;
16898 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16899 bool result;
16900 void *argp1 = 0 ;
16901 int res1 = 0 ;
16902 int val2 ;
16903 int ecode2 = 0 ;
16904 int val3 ;
16905 int ecode3 = 0 ;
16906 unsigned char val4 ;
16907 int ecode4 = 0 ;
16908 PyObject * obj0 = 0 ;
16909 PyObject * obj1 = 0 ;
16910 PyObject * obj2 = 0 ;
16911 PyObject * obj3 = 0 ;
16912 char * kwnames[] = {
16913 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16914 };
16915
16916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16918 if (!SWIG_IsOK(res1)) {
16919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16920 }
16921 arg1 = reinterpret_cast< wxImage * >(argp1);
16922 ecode2 = SWIG_AsVal_int(obj1, &val2);
16923 if (!SWIG_IsOK(ecode2)) {
16924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16925 }
16926 arg2 = static_cast< int >(val2);
16927 ecode3 = SWIG_AsVal_int(obj2, &val3);
16928 if (!SWIG_IsOK(ecode3)) {
16929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16930 }
16931 arg3 = static_cast< int >(val3);
16932 if (obj3) {
16933 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16934 if (!SWIG_IsOK(ecode4)) {
16935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16936 }
16937 arg4 = static_cast< byte >(val4);
16938 }
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 {
16946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16947 }
16948 return resultobj;
16949 fail:
16950 return NULL;
16951 }
16952
16953
16954 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16955 PyObject *resultobj = 0;
16956 wxImage *arg1 = (wxImage *) 0 ;
16957 byte *arg2 = (byte *) 0 ;
16958 byte *arg3 = (byte *) 0 ;
16959 byte *arg4 = (byte *) 0 ;
16960 byte arg5 = (byte) 0 ;
16961 byte arg6 = (byte) 0 ;
16962 byte arg7 = (byte) 0 ;
16963 bool result;
16964 void *argp1 = 0 ;
16965 int res1 = 0 ;
16966 byte temp2 ;
16967 int res2 = SWIG_TMPOBJ ;
16968 byte temp3 ;
16969 int res3 = SWIG_TMPOBJ ;
16970 byte temp4 ;
16971 int res4 = SWIG_TMPOBJ ;
16972 unsigned char val5 ;
16973 int ecode5 = 0 ;
16974 unsigned char val6 ;
16975 int ecode6 = 0 ;
16976 unsigned char val7 ;
16977 int ecode7 = 0 ;
16978 PyObject * obj0 = 0 ;
16979 PyObject * obj1 = 0 ;
16980 PyObject * obj2 = 0 ;
16981 PyObject * obj3 = 0 ;
16982 char * kwnames[] = {
16983 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
16984 };
16985
16986 arg2 = &temp2;
16987 arg3 = &temp3;
16988 arg4 = &temp4;
16989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16993 }
16994 arg1 = reinterpret_cast< wxImage * >(argp1);
16995 if (obj1) {
16996 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
16997 if (!SWIG_IsOK(ecode5)) {
16998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
16999 }
17000 arg5 = static_cast< byte >(val5);
17001 }
17002 if (obj2) {
17003 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17004 if (!SWIG_IsOK(ecode6)) {
17005 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17006 }
17007 arg6 = static_cast< byte >(val6);
17008 }
17009 if (obj3) {
17010 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17011 if (!SWIG_IsOK(ecode7)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17013 }
17014 arg7 = static_cast< byte >(val7);
17015 }
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17019 wxPyEndAllowThreads(__tstate);
17020 if (PyErr_Occurred()) SWIG_fail;
17021 }
17022 {
17023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17024 }
17025 if (SWIG_IsTmpObj(res2)) {
17026 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17027 } else {
17028 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17029 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17030 }
17031 if (SWIG_IsTmpObj(res3)) {
17032 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17033 } else {
17034 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17035 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17036 }
17037 if (SWIG_IsTmpObj(res4)) {
17038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17039 } else {
17040 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17042 }
17043 return resultobj;
17044 fail:
17045 return NULL;
17046 }
17047
17048
17049 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj = 0;
17051 wxImage *arg1 = (wxImage *) 0 ;
17052 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17053 bool result;
17054 void *argp1 = 0 ;
17055 int res1 = 0 ;
17056 unsigned char val2 ;
17057 int ecode2 = 0 ;
17058 PyObject * obj0 = 0 ;
17059 PyObject * obj1 = 0 ;
17060 char * kwnames[] = {
17061 (char *) "self",(char *) "threshold", NULL
17062 };
17063
17064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17066 if (!SWIG_IsOK(res1)) {
17067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17068 }
17069 arg1 = reinterpret_cast< wxImage * >(argp1);
17070 if (obj1) {
17071 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17072 if (!SWIG_IsOK(ecode2)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17074 }
17075 arg2 = static_cast< byte >(val2);
17076 }
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 {
17084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17085 }
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj = 0;
17094 wxImage *arg1 = (wxImage *) 0 ;
17095 byte arg2 ;
17096 byte arg3 ;
17097 byte arg4 ;
17098 bool result;
17099 void *argp1 = 0 ;
17100 int res1 = 0 ;
17101 unsigned char val2 ;
17102 int ecode2 = 0 ;
17103 unsigned char val3 ;
17104 int ecode3 = 0 ;
17105 unsigned char val4 ;
17106 int ecode4 = 0 ;
17107 PyObject * obj0 = 0 ;
17108 PyObject * obj1 = 0 ;
17109 PyObject * obj2 = 0 ;
17110 PyObject * obj3 = 0 ;
17111 char * kwnames[] = {
17112 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17113 };
17114
17115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17117 if (!SWIG_IsOK(res1)) {
17118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17119 }
17120 arg1 = reinterpret_cast< wxImage * >(argp1);
17121 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17122 if (!SWIG_IsOK(ecode2)) {
17123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17124 }
17125 arg2 = static_cast< byte >(val2);
17126 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17127 if (!SWIG_IsOK(ecode3)) {
17128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17129 }
17130 arg3 = static_cast< byte >(val3);
17131 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17132 if (!SWIG_IsOK(ecode4)) {
17133 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17134 }
17135 arg4 = static_cast< byte >(val4);
17136 {
17137 PyThreadState* __tstate = wxPyBeginAllowThreads();
17138 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17139 wxPyEndAllowThreads(__tstate);
17140 if (PyErr_Occurred()) SWIG_fail;
17141 }
17142 {
17143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17144 }
17145 return resultobj;
17146 fail:
17147 return NULL;
17148 }
17149
17150
17151 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17152 PyObject *resultobj = 0;
17153 wxImage *arg1 = (wxImage *) 0 ;
17154 wxImage *arg2 = 0 ;
17155 byte arg3 ;
17156 byte arg4 ;
17157 byte arg5 ;
17158 bool result;
17159 void *argp1 = 0 ;
17160 int res1 = 0 ;
17161 void *argp2 = 0 ;
17162 int res2 = 0 ;
17163 unsigned char val3 ;
17164 int ecode3 = 0 ;
17165 unsigned char val4 ;
17166 int ecode4 = 0 ;
17167 unsigned char val5 ;
17168 int ecode5 = 0 ;
17169 PyObject * obj0 = 0 ;
17170 PyObject * obj1 = 0 ;
17171 PyObject * obj2 = 0 ;
17172 PyObject * obj3 = 0 ;
17173 PyObject * obj4 = 0 ;
17174 char * kwnames[] = {
17175 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17176 };
17177
17178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17180 if (!SWIG_IsOK(res1)) {
17181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17182 }
17183 arg1 = reinterpret_cast< wxImage * >(argp1);
17184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17185 if (!SWIG_IsOK(res2)) {
17186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17187 }
17188 if (!argp2) {
17189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17190 }
17191 arg2 = reinterpret_cast< wxImage * >(argp2);
17192 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17193 if (!SWIG_IsOK(ecode3)) {
17194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17195 }
17196 arg3 = static_cast< byte >(val3);
17197 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17198 if (!SWIG_IsOK(ecode4)) {
17199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17200 }
17201 arg4 = static_cast< byte >(val4);
17202 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17203 if (!SWIG_IsOK(ecode5)) {
17204 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17205 }
17206 arg5 = static_cast< byte >(val5);
17207 {
17208 PyThreadState* __tstate = wxPyBeginAllowThreads();
17209 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17210 wxPyEndAllowThreads(__tstate);
17211 if (PyErr_Occurred()) SWIG_fail;
17212 }
17213 {
17214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17215 }
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj = 0;
17224 wxString *arg1 = 0 ;
17225 bool result;
17226 bool temp1 = false ;
17227 PyObject * obj0 = 0 ;
17228 char * kwnames[] = {
17229 (char *) "filename", NULL
17230 };
17231
17232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17233 {
17234 arg1 = wxString_in_helper(obj0);
17235 if (arg1 == NULL) SWIG_fail;
17236 temp1 = true;
17237 }
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 {
17245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17246 }
17247 {
17248 if (temp1)
17249 delete arg1;
17250 }
17251 return resultobj;
17252 fail:
17253 {
17254 if (temp1)
17255 delete arg1;
17256 }
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj = 0;
17263 wxString *arg1 = 0 ;
17264 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17265 int result;
17266 bool temp1 = false ;
17267 long val2 ;
17268 int ecode2 = 0 ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 char * kwnames[] = {
17272 (char *) "filename",(char *) "type", NULL
17273 };
17274
17275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17276 {
17277 arg1 = wxString_in_helper(obj0);
17278 if (arg1 == NULL) SWIG_fail;
17279 temp1 = true;
17280 }
17281 if (obj1) {
17282 ecode2 = SWIG_AsVal_long(obj1, &val2);
17283 if (!SWIG_IsOK(ecode2)) {
17284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17285 }
17286 arg2 = static_cast< long >(val2);
17287 }
17288 {
17289 PyThreadState* __tstate = wxPyBeginAllowThreads();
17290 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17291 wxPyEndAllowThreads(__tstate);
17292 if (PyErr_Occurred()) SWIG_fail;
17293 }
17294 resultobj = SWIG_From_int(static_cast< int >(result));
17295 {
17296 if (temp1)
17297 delete arg1;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp1)
17303 delete arg1;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxImage *arg1 = (wxImage *) 0 ;
17312 wxString *arg2 = 0 ;
17313 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17314 int arg4 = (int) -1 ;
17315 bool result;
17316 void *argp1 = 0 ;
17317 int res1 = 0 ;
17318 bool temp2 = false ;
17319 long val3 ;
17320 int ecode3 = 0 ;
17321 int val4 ;
17322 int ecode4 = 0 ;
17323 PyObject * obj0 = 0 ;
17324 PyObject * obj1 = 0 ;
17325 PyObject * obj2 = 0 ;
17326 PyObject * obj3 = 0 ;
17327 char * kwnames[] = {
17328 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17329 };
17330
17331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17333 if (!SWIG_IsOK(res1)) {
17334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17335 }
17336 arg1 = reinterpret_cast< wxImage * >(argp1);
17337 {
17338 arg2 = wxString_in_helper(obj1);
17339 if (arg2 == NULL) SWIG_fail;
17340 temp2 = true;
17341 }
17342 if (obj2) {
17343 ecode3 = SWIG_AsVal_long(obj2, &val3);
17344 if (!SWIG_IsOK(ecode3)) {
17345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17346 }
17347 arg3 = static_cast< long >(val3);
17348 }
17349 if (obj3) {
17350 ecode4 = SWIG_AsVal_int(obj3, &val4);
17351 if (!SWIG_IsOK(ecode4)) {
17352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17353 }
17354 arg4 = static_cast< int >(val4);
17355 }
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 {
17363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17364 }
17365 {
17366 if (temp2)
17367 delete arg2;
17368 }
17369 return resultobj;
17370 fail:
17371 {
17372 if (temp2)
17373 delete arg2;
17374 }
17375 return NULL;
17376 }
17377
17378
17379 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17380 PyObject *resultobj = 0;
17381 wxImage *arg1 = (wxImage *) 0 ;
17382 wxString *arg2 = 0 ;
17383 wxString *arg3 = 0 ;
17384 int arg4 = (int) -1 ;
17385 bool result;
17386 void *argp1 = 0 ;
17387 int res1 = 0 ;
17388 bool temp2 = false ;
17389 bool temp3 = false ;
17390 int val4 ;
17391 int ecode4 = 0 ;
17392 PyObject * obj0 = 0 ;
17393 PyObject * obj1 = 0 ;
17394 PyObject * obj2 = 0 ;
17395 PyObject * obj3 = 0 ;
17396 char * kwnames[] = {
17397 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17398 };
17399
17400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17402 if (!SWIG_IsOK(res1)) {
17403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17404 }
17405 arg1 = reinterpret_cast< wxImage * >(argp1);
17406 {
17407 arg2 = wxString_in_helper(obj1);
17408 if (arg2 == NULL) SWIG_fail;
17409 temp2 = true;
17410 }
17411 {
17412 arg3 = wxString_in_helper(obj2);
17413 if (arg3 == NULL) SWIG_fail;
17414 temp3 = true;
17415 }
17416 if (obj3) {
17417 ecode4 = SWIG_AsVal_int(obj3, &val4);
17418 if (!SWIG_IsOK(ecode4)) {
17419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17420 }
17421 arg4 = static_cast< int >(val4);
17422 }
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 {
17430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17431 }
17432 {
17433 if (temp2)
17434 delete arg2;
17435 }
17436 {
17437 if (temp3)
17438 delete arg3;
17439 }
17440 return resultobj;
17441 fail:
17442 {
17443 if (temp2)
17444 delete arg2;
17445 }
17446 {
17447 if (temp3)
17448 delete arg3;
17449 }
17450 return NULL;
17451 }
17452
17453
17454 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17455 PyObject *resultobj = 0;
17456 wxImage *arg1 = (wxImage *) 0 ;
17457 wxString *arg2 = 0 ;
17458 int arg3 ;
17459 bool result;
17460 void *argp1 = 0 ;
17461 int res1 = 0 ;
17462 bool temp2 = false ;
17463 int val3 ;
17464 int ecode3 = 0 ;
17465 PyObject * obj0 = 0 ;
17466 PyObject * obj1 = 0 ;
17467 PyObject * obj2 = 0 ;
17468 char * kwnames[] = {
17469 (char *) "self",(char *) "name",(char *) "type", NULL
17470 };
17471
17472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17474 if (!SWIG_IsOK(res1)) {
17475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17476 }
17477 arg1 = reinterpret_cast< wxImage * >(argp1);
17478 {
17479 arg2 = wxString_in_helper(obj1);
17480 if (arg2 == NULL) SWIG_fail;
17481 temp2 = true;
17482 }
17483 ecode3 = SWIG_AsVal_int(obj2, &val3);
17484 if (!SWIG_IsOK(ecode3)) {
17485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17486 }
17487 arg3 = static_cast< int >(val3);
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17491 wxPyEndAllowThreads(__tstate);
17492 if (PyErr_Occurred()) SWIG_fail;
17493 }
17494 {
17495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17496 }
17497 {
17498 if (temp2)
17499 delete arg2;
17500 }
17501 return resultobj;
17502 fail:
17503 {
17504 if (temp2)
17505 delete arg2;
17506 }
17507 return NULL;
17508 }
17509
17510
17511 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17512 PyObject *resultobj = 0;
17513 wxImage *arg1 = (wxImage *) 0 ;
17514 wxString *arg2 = 0 ;
17515 wxString *arg3 = 0 ;
17516 bool result;
17517 void *argp1 = 0 ;
17518 int res1 = 0 ;
17519 bool temp2 = false ;
17520 bool temp3 = false ;
17521 PyObject * obj0 = 0 ;
17522 PyObject * obj1 = 0 ;
17523 PyObject * obj2 = 0 ;
17524 char * kwnames[] = {
17525 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17526 };
17527
17528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17530 if (!SWIG_IsOK(res1)) {
17531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17532 }
17533 arg1 = reinterpret_cast< wxImage * >(argp1);
17534 {
17535 arg2 = wxString_in_helper(obj1);
17536 if (arg2 == NULL) SWIG_fail;
17537 temp2 = true;
17538 }
17539 {
17540 arg3 = wxString_in_helper(obj2);
17541 if (arg3 == NULL) SWIG_fail;
17542 temp3 = true;
17543 }
17544 {
17545 PyThreadState* __tstate = wxPyBeginAllowThreads();
17546 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17547 wxPyEndAllowThreads(__tstate);
17548 if (PyErr_Occurred()) SWIG_fail;
17549 }
17550 {
17551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17552 }
17553 {
17554 if (temp2)
17555 delete arg2;
17556 }
17557 {
17558 if (temp3)
17559 delete arg3;
17560 }
17561 return resultobj;
17562 fail:
17563 {
17564 if (temp2)
17565 delete arg2;
17566 }
17567 {
17568 if (temp3)
17569 delete arg3;
17570 }
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxInputStream *arg1 = 0 ;
17578 bool result;
17579 wxPyInputStream *temp1 ;
17580 bool created1 ;
17581 PyObject * obj0 = 0 ;
17582 char * kwnames[] = {
17583 (char *) "stream", NULL
17584 };
17585
17586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17587 {
17588 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17589 arg1 = temp1->m_wxis;
17590 created1 = false;
17591 } else {
17592 PyErr_Clear(); // clear the failure of the wxPyConvert above
17593 arg1 = wxPyCBInputStream_create(obj0, false);
17594 if (arg1 == NULL) {
17595 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17596 SWIG_fail;
17597 }
17598 created1 = true;
17599 }
17600 }
17601 {
17602 PyThreadState* __tstate = wxPyBeginAllowThreads();
17603 result = (bool)wxImage::CanRead(*arg1);
17604 wxPyEndAllowThreads(__tstate);
17605 if (PyErr_Occurred()) SWIG_fail;
17606 }
17607 {
17608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17609 }
17610 {
17611 if (created1) delete arg1;
17612 }
17613 return resultobj;
17614 fail:
17615 {
17616 if (created1) delete arg1;
17617 }
17618 return NULL;
17619 }
17620
17621
17622 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj = 0;
17624 wxImage *arg1 = (wxImage *) 0 ;
17625 wxInputStream *arg2 = 0 ;
17626 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17627 int arg4 = (int) -1 ;
17628 bool result;
17629 void *argp1 = 0 ;
17630 int res1 = 0 ;
17631 wxPyInputStream *temp2 ;
17632 bool created2 ;
17633 long val3 ;
17634 int ecode3 = 0 ;
17635 int val4 ;
17636 int ecode4 = 0 ;
17637 PyObject * obj0 = 0 ;
17638 PyObject * obj1 = 0 ;
17639 PyObject * obj2 = 0 ;
17640 PyObject * obj3 = 0 ;
17641 char * kwnames[] = {
17642 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17643 };
17644
17645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17647 if (!SWIG_IsOK(res1)) {
17648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17649 }
17650 arg1 = reinterpret_cast< wxImage * >(argp1);
17651 {
17652 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17653 arg2 = temp2->m_wxis;
17654 created2 = false;
17655 } else {
17656 PyErr_Clear(); // clear the failure of the wxPyConvert above
17657 arg2 = wxPyCBInputStream_create(obj1, false);
17658 if (arg2 == NULL) {
17659 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17660 SWIG_fail;
17661 }
17662 created2 = true;
17663 }
17664 }
17665 if (obj2) {
17666 ecode3 = SWIG_AsVal_long(obj2, &val3);
17667 if (!SWIG_IsOK(ecode3)) {
17668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17669 }
17670 arg3 = static_cast< long >(val3);
17671 }
17672 if (obj3) {
17673 ecode4 = SWIG_AsVal_int(obj3, &val4);
17674 if (!SWIG_IsOK(ecode4)) {
17675 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17676 }
17677 arg4 = static_cast< int >(val4);
17678 }
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 {
17686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17687 }
17688 {
17689 if (created2) delete arg2;
17690 }
17691 return resultobj;
17692 fail:
17693 {
17694 if (created2) delete arg2;
17695 }
17696 return NULL;
17697 }
17698
17699
17700 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17701 PyObject *resultobj = 0;
17702 wxImage *arg1 = (wxImage *) 0 ;
17703 wxInputStream *arg2 = 0 ;
17704 wxString *arg3 = 0 ;
17705 int arg4 = (int) -1 ;
17706 bool result;
17707 void *argp1 = 0 ;
17708 int res1 = 0 ;
17709 wxPyInputStream *temp2 ;
17710 bool created2 ;
17711 bool temp3 = false ;
17712 int val4 ;
17713 int ecode4 = 0 ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 PyObject * obj2 = 0 ;
17717 PyObject * obj3 = 0 ;
17718 char * kwnames[] = {
17719 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17720 };
17721
17722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17724 if (!SWIG_IsOK(res1)) {
17725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17726 }
17727 arg1 = reinterpret_cast< wxImage * >(argp1);
17728 {
17729 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17730 arg2 = temp2->m_wxis;
17731 created2 = false;
17732 } else {
17733 PyErr_Clear(); // clear the failure of the wxPyConvert above
17734 arg2 = wxPyCBInputStream_create(obj1, false);
17735 if (arg2 == NULL) {
17736 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17737 SWIG_fail;
17738 }
17739 created2 = true;
17740 }
17741 }
17742 {
17743 arg3 = wxString_in_helper(obj2);
17744 if (arg3 == NULL) SWIG_fail;
17745 temp3 = true;
17746 }
17747 if (obj3) {
17748 ecode4 = SWIG_AsVal_int(obj3, &val4);
17749 if (!SWIG_IsOK(ecode4)) {
17750 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17751 }
17752 arg4 = static_cast< int >(val4);
17753 }
17754 {
17755 PyThreadState* __tstate = wxPyBeginAllowThreads();
17756 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17757 wxPyEndAllowThreads(__tstate);
17758 if (PyErr_Occurred()) SWIG_fail;
17759 }
17760 {
17761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17762 }
17763 {
17764 if (created2) delete arg2;
17765 }
17766 {
17767 if (temp3)
17768 delete arg3;
17769 }
17770 return resultobj;
17771 fail:
17772 {
17773 if (created2) delete arg2;
17774 }
17775 {
17776 if (temp3)
17777 delete arg3;
17778 }
17779 return NULL;
17780 }
17781
17782
17783 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17784 PyObject *resultobj = 0;
17785 wxImage *arg1 = (wxImage *) 0 ;
17786 bool result;
17787 void *argp1 = 0 ;
17788 int res1 = 0 ;
17789 PyObject *swig_obj[1] ;
17790
17791 if (!args) SWIG_fail;
17792 swig_obj[0] = args;
17793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17794 if (!SWIG_IsOK(res1)) {
17795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17796 }
17797 arg1 = reinterpret_cast< wxImage * >(argp1);
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)(arg1)->IsOk();
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17806 }
17807 return resultobj;
17808 fail:
17809 return NULL;
17810 }
17811
17812
17813 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17814 PyObject *resultobj = 0;
17815 wxImage *arg1 = (wxImage *) 0 ;
17816 int result;
17817 void *argp1 = 0 ;
17818 int res1 = 0 ;
17819 PyObject *swig_obj[1] ;
17820
17821 if (!args) SWIG_fail;
17822 swig_obj[0] = args;
17823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17824 if (!SWIG_IsOK(res1)) {
17825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17826 }
17827 arg1 = reinterpret_cast< wxImage * >(argp1);
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 result = (int)(arg1)->GetWidth();
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 resultobj = SWIG_From_int(static_cast< int >(result));
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17842 PyObject *resultobj = 0;
17843 wxImage *arg1 = (wxImage *) 0 ;
17844 int result;
17845 void *argp1 = 0 ;
17846 int res1 = 0 ;
17847 PyObject *swig_obj[1] ;
17848
17849 if (!args) SWIG_fail;
17850 swig_obj[0] = args;
17851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17854 }
17855 arg1 = reinterpret_cast< wxImage * >(argp1);
17856 {
17857 PyThreadState* __tstate = wxPyBeginAllowThreads();
17858 result = (int)(arg1)->GetHeight();
17859 wxPyEndAllowThreads(__tstate);
17860 if (PyErr_Occurred()) SWIG_fail;
17861 }
17862 resultobj = SWIG_From_int(static_cast< int >(result));
17863 return resultobj;
17864 fail:
17865 return NULL;
17866 }
17867
17868
17869 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17870 PyObject *resultobj = 0;
17871 wxImage *arg1 = (wxImage *) 0 ;
17872 wxSize result;
17873 void *argp1 = 0 ;
17874 int res1 = 0 ;
17875 PyObject *swig_obj[1] ;
17876
17877 if (!args) SWIG_fail;
17878 swig_obj[0] = args;
17879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17880 if (!SWIG_IsOK(res1)) {
17881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17882 }
17883 arg1 = reinterpret_cast< wxImage * >(argp1);
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 result = wxImage_GetSize(arg1);
17887 wxPyEndAllowThreads(__tstate);
17888 if (PyErr_Occurred()) SWIG_fail;
17889 }
17890 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17898 PyObject *resultobj = 0;
17899 wxImage *arg1 = (wxImage *) 0 ;
17900 wxRect *arg2 = 0 ;
17901 SwigValueWrapper<wxImage > result;
17902 void *argp1 = 0 ;
17903 int res1 = 0 ;
17904 wxRect temp2 ;
17905 PyObject * obj0 = 0 ;
17906 PyObject * obj1 = 0 ;
17907 char * kwnames[] = {
17908 (char *) "self",(char *) "rect", NULL
17909 };
17910
17911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17915 }
17916 arg1 = reinterpret_cast< wxImage * >(argp1);
17917 {
17918 arg2 = &temp2;
17919 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17920 }
17921 {
17922 PyThreadState* __tstate = wxPyBeginAllowThreads();
17923 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17924 wxPyEndAllowThreads(__tstate);
17925 if (PyErr_Occurred()) SWIG_fail;
17926 }
17927 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17928 return resultobj;
17929 fail:
17930 return NULL;
17931 }
17932
17933
17934 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17935 PyObject *resultobj = 0;
17936 wxImage *arg1 = (wxImage *) 0 ;
17937 wxSize *arg2 = 0 ;
17938 wxPoint *arg3 = 0 ;
17939 int arg4 = (int) -1 ;
17940 int arg5 = (int) -1 ;
17941 int arg6 = (int) -1 ;
17942 SwigValueWrapper<wxImage > result;
17943 void *argp1 = 0 ;
17944 int res1 = 0 ;
17945 wxSize temp2 ;
17946 wxPoint temp3 ;
17947 int val4 ;
17948 int ecode4 = 0 ;
17949 int val5 ;
17950 int ecode5 = 0 ;
17951 int val6 ;
17952 int ecode6 = 0 ;
17953 PyObject * obj0 = 0 ;
17954 PyObject * obj1 = 0 ;
17955 PyObject * obj2 = 0 ;
17956 PyObject * obj3 = 0 ;
17957 PyObject * obj4 = 0 ;
17958 PyObject * obj5 = 0 ;
17959 char * kwnames[] = {
17960 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17961 };
17962
17963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17965 if (!SWIG_IsOK(res1)) {
17966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
17967 }
17968 arg1 = reinterpret_cast< wxImage * >(argp1);
17969 {
17970 arg2 = &temp2;
17971 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17972 }
17973 {
17974 arg3 = &temp3;
17975 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17976 }
17977 if (obj3) {
17978 ecode4 = SWIG_AsVal_int(obj3, &val4);
17979 if (!SWIG_IsOK(ecode4)) {
17980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
17981 }
17982 arg4 = static_cast< int >(val4);
17983 }
17984 if (obj4) {
17985 ecode5 = SWIG_AsVal_int(obj4, &val5);
17986 if (!SWIG_IsOK(ecode5)) {
17987 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
17988 }
17989 arg5 = static_cast< int >(val5);
17990 }
17991 if (obj5) {
17992 ecode6 = SWIG_AsVal_int(obj5, &val6);
17993 if (!SWIG_IsOK(ecode6)) {
17994 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
17995 }
17996 arg6 = static_cast< int >(val6);
17997 }
17998 {
17999 PyThreadState* __tstate = wxPyBeginAllowThreads();
18000 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18005 return resultobj;
18006 fail:
18007 return NULL;
18008 }
18009
18010
18011 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18012 PyObject *resultobj = 0;
18013 wxImage *arg1 = (wxImage *) 0 ;
18014 SwigValueWrapper<wxImage > result;
18015 void *argp1 = 0 ;
18016 int res1 = 0 ;
18017 PyObject *swig_obj[1] ;
18018
18019 if (!args) SWIG_fail;
18020 swig_obj[0] = args;
18021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18022 if (!SWIG_IsOK(res1)) {
18023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18024 }
18025 arg1 = reinterpret_cast< wxImage * >(argp1);
18026 {
18027 PyThreadState* __tstate = wxPyBeginAllowThreads();
18028 result = (arg1)->Copy();
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj = 0;
18041 wxImage *arg1 = (wxImage *) 0 ;
18042 wxImage *arg2 = 0 ;
18043 int arg3 ;
18044 int arg4 ;
18045 void *argp1 = 0 ;
18046 int res1 = 0 ;
18047 void *argp2 = 0 ;
18048 int res2 = 0 ;
18049 int val3 ;
18050 int ecode3 = 0 ;
18051 int val4 ;
18052 int ecode4 = 0 ;
18053 PyObject * obj0 = 0 ;
18054 PyObject * obj1 = 0 ;
18055 PyObject * obj2 = 0 ;
18056 PyObject * obj3 = 0 ;
18057 char * kwnames[] = {
18058 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18059 };
18060
18061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18063 if (!SWIG_IsOK(res1)) {
18064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18065 }
18066 arg1 = reinterpret_cast< wxImage * >(argp1);
18067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18068 if (!SWIG_IsOK(res2)) {
18069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18070 }
18071 if (!argp2) {
18072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18073 }
18074 arg2 = reinterpret_cast< wxImage * >(argp2);
18075 ecode3 = SWIG_AsVal_int(obj2, &val3);
18076 if (!SWIG_IsOK(ecode3)) {
18077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18078 }
18079 arg3 = static_cast< int >(val3);
18080 ecode4 = SWIG_AsVal_int(obj3, &val4);
18081 if (!SWIG_IsOK(ecode4)) {
18082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18083 }
18084 arg4 = static_cast< int >(val4);
18085 {
18086 PyThreadState* __tstate = wxPyBeginAllowThreads();
18087 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18088 wxPyEndAllowThreads(__tstate);
18089 if (PyErr_Occurred()) SWIG_fail;
18090 }
18091 resultobj = SWIG_Py_Void();
18092 return resultobj;
18093 fail:
18094 return NULL;
18095 }
18096
18097
18098 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18099 PyObject *resultobj = 0;
18100 wxImage *arg1 = (wxImage *) 0 ;
18101 PyObject *result = 0 ;
18102 void *argp1 = 0 ;
18103 int res1 = 0 ;
18104 PyObject *swig_obj[1] ;
18105
18106 if (!args) SWIG_fail;
18107 swig_obj[0] = args;
18108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18109 if (!SWIG_IsOK(res1)) {
18110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18111 }
18112 arg1 = reinterpret_cast< wxImage * >(argp1);
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 result = (PyObject *)wxImage_GetData(arg1);
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 resultobj = result;
18120 return resultobj;
18121 fail:
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18127 PyObject *resultobj = 0;
18128 wxImage *arg1 = (wxImage *) 0 ;
18129 buffer arg2 ;
18130 int arg3 ;
18131 void *argp1 = 0 ;
18132 int res1 = 0 ;
18133 Py_ssize_t temp2 ;
18134 PyObject * obj0 = 0 ;
18135 PyObject * obj1 = 0 ;
18136 char * kwnames[] = {
18137 (char *) "self",(char *) "data", NULL
18138 };
18139
18140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18142 if (!SWIG_IsOK(res1)) {
18143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18144 }
18145 arg1 = reinterpret_cast< wxImage * >(argp1);
18146 {
18147 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18148 arg3 = (int)temp2;
18149 }
18150 {
18151 PyThreadState* __tstate = wxPyBeginAllowThreads();
18152 wxImage_SetData(arg1,arg2,arg3);
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = SWIG_Py_Void();
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 wxImage *arg1 = (wxImage *) 0 ;
18166 PyObject *result = 0 ;
18167 void *argp1 = 0 ;
18168 int res1 = 0 ;
18169 PyObject *swig_obj[1] ;
18170
18171 if (!args) SWIG_fail;
18172 swig_obj[0] = args;
18173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18174 if (!SWIG_IsOK(res1)) {
18175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18176 }
18177 arg1 = reinterpret_cast< wxImage * >(argp1);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = result;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj = 0;
18193 wxImage *arg1 = (wxImage *) 0 ;
18194 buffer arg2 ;
18195 int arg3 ;
18196 void *argp1 = 0 ;
18197 int res1 = 0 ;
18198 Py_ssize_t temp2 ;
18199 PyObject * obj0 = 0 ;
18200 PyObject * obj1 = 0 ;
18201 char * kwnames[] = {
18202 (char *) "self",(char *) "data", NULL
18203 };
18204
18205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18207 if (!SWIG_IsOK(res1)) {
18208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18209 }
18210 arg1 = reinterpret_cast< wxImage * >(argp1);
18211 {
18212 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18213 arg3 = (int)temp2;
18214 }
18215 {
18216 PyThreadState* __tstate = wxPyBeginAllowThreads();
18217 wxImage_SetDataBuffer(arg1,arg2,arg3);
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 resultobj = SWIG_Py_Void();
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18229 PyObject *resultobj = 0;
18230 wxImage *arg1 = (wxImage *) 0 ;
18231 PyObject *result = 0 ;
18232 void *argp1 = 0 ;
18233 int res1 = 0 ;
18234 PyObject *swig_obj[1] ;
18235
18236 if (!args) SWIG_fail;
18237 swig_obj[0] = args;
18238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18239 if (!SWIG_IsOK(res1)) {
18240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18241 }
18242 arg1 = reinterpret_cast< wxImage * >(argp1);
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (PyObject *)wxImage_GetAlphaData(arg1);
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 resultobj = result;
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18257 PyObject *resultobj = 0;
18258 wxImage *arg1 = (wxImage *) 0 ;
18259 buffer arg2 ;
18260 int arg3 ;
18261 void *argp1 = 0 ;
18262 int res1 = 0 ;
18263 Py_ssize_t temp2 ;
18264 PyObject * obj0 = 0 ;
18265 PyObject * obj1 = 0 ;
18266 char * kwnames[] = {
18267 (char *) "self",(char *) "alpha", NULL
18268 };
18269
18270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18272 if (!SWIG_IsOK(res1)) {
18273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18274 }
18275 arg1 = reinterpret_cast< wxImage * >(argp1);
18276 {
18277 if (obj1 != Py_None) {
18278 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18279 arg3 = (int)temp2;
18280 }
18281 }
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 wxImage_SetAlphaData(arg1,arg2,arg3);
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = SWIG_Py_Void();
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18296 PyObject *resultobj = 0;
18297 wxImage *arg1 = (wxImage *) 0 ;
18298 PyObject *result = 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 PyObject *swig_obj[1] ;
18302
18303 if (!args) SWIG_fail;
18304 swig_obj[0] = args;
18305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18306 if (!SWIG_IsOK(res1)) {
18307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18308 }
18309 arg1 = reinterpret_cast< wxImage * >(argp1);
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 resultobj = result;
18317 return resultobj;
18318 fail:
18319 return NULL;
18320 }
18321
18322
18323 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18324 PyObject *resultobj = 0;
18325 wxImage *arg1 = (wxImage *) 0 ;
18326 buffer arg2 ;
18327 int arg3 ;
18328 void *argp1 = 0 ;
18329 int res1 = 0 ;
18330 Py_ssize_t temp2 ;
18331 PyObject * obj0 = 0 ;
18332 PyObject * obj1 = 0 ;
18333 char * kwnames[] = {
18334 (char *) "self",(char *) "alpha", NULL
18335 };
18336
18337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18339 if (!SWIG_IsOK(res1)) {
18340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18341 }
18342 arg1 = reinterpret_cast< wxImage * >(argp1);
18343 {
18344 if (obj1 != Py_None) {
18345 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18346 arg3 = (int)temp2;
18347 }
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_Py_Void();
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj = 0;
18364 wxImage *arg1 = (wxImage *) 0 ;
18365 byte arg2 ;
18366 byte arg3 ;
18367 byte arg4 ;
18368 void *argp1 = 0 ;
18369 int res1 = 0 ;
18370 unsigned char val2 ;
18371 int ecode2 = 0 ;
18372 unsigned char val3 ;
18373 int ecode3 = 0 ;
18374 unsigned char val4 ;
18375 int ecode4 = 0 ;
18376 PyObject * obj0 = 0 ;
18377 PyObject * obj1 = 0 ;
18378 PyObject * obj2 = 0 ;
18379 PyObject * obj3 = 0 ;
18380 char * kwnames[] = {
18381 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18382 };
18383
18384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18386 if (!SWIG_IsOK(res1)) {
18387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18388 }
18389 arg1 = reinterpret_cast< wxImage * >(argp1);
18390 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18391 if (!SWIG_IsOK(ecode2)) {
18392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18393 }
18394 arg2 = static_cast< byte >(val2);
18395 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18396 if (!SWIG_IsOK(ecode3)) {
18397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18398 }
18399 arg3 = static_cast< byte >(val3);
18400 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18401 if (!SWIG_IsOK(ecode4)) {
18402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18403 }
18404 arg4 = static_cast< byte >(val4);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 (arg1)->SetMaskColour(arg2,arg3,arg4);
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 resultobj = SWIG_Py_Void();
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18419 PyObject *resultobj = 0;
18420 wxImage *arg1 = (wxImage *) 0 ;
18421 byte *arg2 = (byte *) 0 ;
18422 byte *arg3 = (byte *) 0 ;
18423 byte *arg4 = (byte *) 0 ;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 byte temp2 ;
18427 int res2 = SWIG_TMPOBJ ;
18428 byte temp3 ;
18429 int res3 = SWIG_TMPOBJ ;
18430 byte temp4 ;
18431 int res4 = SWIG_TMPOBJ ;
18432 PyObject *swig_obj[1] ;
18433
18434 arg2 = &temp2;
18435 arg3 = &temp3;
18436 arg4 = &temp4;
18437 if (!args) SWIG_fail;
18438 swig_obj[0] = args;
18439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18440 if (!SWIG_IsOK(res1)) {
18441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18442 }
18443 arg1 = reinterpret_cast< wxImage * >(argp1);
18444 {
18445 PyThreadState* __tstate = wxPyBeginAllowThreads();
18446 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18447 wxPyEndAllowThreads(__tstate);
18448 if (PyErr_Occurred()) SWIG_fail;
18449 }
18450 resultobj = SWIG_Py_Void();
18451 if (SWIG_IsTmpObj(res2)) {
18452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18453 } else {
18454 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18456 }
18457 if (SWIG_IsTmpObj(res3)) {
18458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18459 } else {
18460 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18462 }
18463 if (SWIG_IsTmpObj(res4)) {
18464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18465 } else {
18466 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18468 }
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18476 PyObject *resultobj = 0;
18477 wxImage *arg1 = (wxImage *) 0 ;
18478 byte result;
18479 void *argp1 = 0 ;
18480 int res1 = 0 ;
18481 PyObject *swig_obj[1] ;
18482
18483 if (!args) SWIG_fail;
18484 swig_obj[0] = args;
18485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18486 if (!SWIG_IsOK(res1)) {
18487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18488 }
18489 arg1 = reinterpret_cast< wxImage * >(argp1);
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 result = (byte)(arg1)->GetMaskRed();
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18504 PyObject *resultobj = 0;
18505 wxImage *arg1 = (wxImage *) 0 ;
18506 byte result;
18507 void *argp1 = 0 ;
18508 int res1 = 0 ;
18509 PyObject *swig_obj[1] ;
18510
18511 if (!args) SWIG_fail;
18512 swig_obj[0] = args;
18513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18514 if (!SWIG_IsOK(res1)) {
18515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18516 }
18517 arg1 = reinterpret_cast< wxImage * >(argp1);
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (byte)(arg1)->GetMaskGreen();
18521 wxPyEndAllowThreads(__tstate);
18522 if (PyErr_Occurred()) SWIG_fail;
18523 }
18524 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18532 PyObject *resultobj = 0;
18533 wxImage *arg1 = (wxImage *) 0 ;
18534 byte result;
18535 void *argp1 = 0 ;
18536 int res1 = 0 ;
18537 PyObject *swig_obj[1] ;
18538
18539 if (!args) SWIG_fail;
18540 swig_obj[0] = args;
18541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18542 if (!SWIG_IsOK(res1)) {
18543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18544 }
18545 arg1 = reinterpret_cast< wxImage * >(argp1);
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 result = (byte)(arg1)->GetMaskBlue();
18549 wxPyEndAllowThreads(__tstate);
18550 if (PyErr_Occurred()) SWIG_fail;
18551 }
18552 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj = 0;
18561 wxImage *arg1 = (wxImage *) 0 ;
18562 bool arg2 = (bool) true ;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 bool val2 ;
18566 int ecode2 = 0 ;
18567 PyObject * obj0 = 0 ;
18568 PyObject * obj1 = 0 ;
18569 char * kwnames[] = {
18570 (char *) "self",(char *) "mask", NULL
18571 };
18572
18573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18577 }
18578 arg1 = reinterpret_cast< wxImage * >(argp1);
18579 if (obj1) {
18580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18581 if (!SWIG_IsOK(ecode2)) {
18582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18583 }
18584 arg2 = static_cast< bool >(val2);
18585 }
18586 {
18587 PyThreadState* __tstate = wxPyBeginAllowThreads();
18588 (arg1)->SetMask(arg2);
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_Py_Void();
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18600 PyObject *resultobj = 0;
18601 wxImage *arg1 = (wxImage *) 0 ;
18602 bool result;
18603 void *argp1 = 0 ;
18604 int res1 = 0 ;
18605 PyObject *swig_obj[1] ;
18606
18607 if (!args) SWIG_fail;
18608 swig_obj[0] = args;
18609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18610 if (!SWIG_IsOK(res1)) {
18611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18612 }
18613 arg1 = reinterpret_cast< wxImage * >(argp1);
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 result = (bool)(arg1)->HasMask();
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj = 0;
18631 wxImage *arg1 = (wxImage *) 0 ;
18632 double arg2 ;
18633 wxPoint *arg3 = 0 ;
18634 bool arg4 = (bool) true ;
18635 wxPoint *arg5 = (wxPoint *) NULL ;
18636 SwigValueWrapper<wxImage > result;
18637 void *argp1 = 0 ;
18638 int res1 = 0 ;
18639 double val2 ;
18640 int ecode2 = 0 ;
18641 wxPoint temp3 ;
18642 bool val4 ;
18643 int ecode4 = 0 ;
18644 void *argp5 = 0 ;
18645 int res5 = 0 ;
18646 PyObject * obj0 = 0 ;
18647 PyObject * obj1 = 0 ;
18648 PyObject * obj2 = 0 ;
18649 PyObject * obj3 = 0 ;
18650 PyObject * obj4 = 0 ;
18651 char * kwnames[] = {
18652 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18653 };
18654
18655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18657 if (!SWIG_IsOK(res1)) {
18658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18659 }
18660 arg1 = reinterpret_cast< wxImage * >(argp1);
18661 ecode2 = SWIG_AsVal_double(obj1, &val2);
18662 if (!SWIG_IsOK(ecode2)) {
18663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18664 }
18665 arg2 = static_cast< double >(val2);
18666 {
18667 arg3 = &temp3;
18668 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18669 }
18670 if (obj3) {
18671 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18672 if (!SWIG_IsOK(ecode4)) {
18673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18674 }
18675 arg4 = static_cast< bool >(val4);
18676 }
18677 if (obj4) {
18678 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18679 if (!SWIG_IsOK(res5)) {
18680 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18681 }
18682 arg5 = reinterpret_cast< wxPoint * >(argp5);
18683 }
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18698 PyObject *resultobj = 0;
18699 wxImage *arg1 = (wxImage *) 0 ;
18700 bool arg2 = (bool) true ;
18701 SwigValueWrapper<wxImage > result;
18702 void *argp1 = 0 ;
18703 int res1 = 0 ;
18704 bool val2 ;
18705 int ecode2 = 0 ;
18706 PyObject * obj0 = 0 ;
18707 PyObject * obj1 = 0 ;
18708 char * kwnames[] = {
18709 (char *) "self",(char *) "clockwise", NULL
18710 };
18711
18712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18714 if (!SWIG_IsOK(res1)) {
18715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18716 }
18717 arg1 = reinterpret_cast< wxImage * >(argp1);
18718 if (obj1) {
18719 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18720 if (!SWIG_IsOK(ecode2)) {
18721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18722 }
18723 arg2 = static_cast< bool >(val2);
18724 }
18725 {
18726 PyThreadState* __tstate = wxPyBeginAllowThreads();
18727 result = (arg1)->Rotate90(arg2);
18728 wxPyEndAllowThreads(__tstate);
18729 if (PyErr_Occurred()) SWIG_fail;
18730 }
18731 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18732 return resultobj;
18733 fail:
18734 return NULL;
18735 }
18736
18737
18738 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18739 PyObject *resultobj = 0;
18740 wxImage *arg1 = (wxImage *) 0 ;
18741 bool arg2 = (bool) true ;
18742 SwigValueWrapper<wxImage > result;
18743 void *argp1 = 0 ;
18744 int res1 = 0 ;
18745 bool val2 ;
18746 int ecode2 = 0 ;
18747 PyObject * obj0 = 0 ;
18748 PyObject * obj1 = 0 ;
18749 char * kwnames[] = {
18750 (char *) "self",(char *) "horizontally", NULL
18751 };
18752
18753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18757 }
18758 arg1 = reinterpret_cast< wxImage * >(argp1);
18759 if (obj1) {
18760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18761 if (!SWIG_IsOK(ecode2)) {
18762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18763 }
18764 arg2 = static_cast< bool >(val2);
18765 }
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 result = (arg1)->Mirror(arg2);
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj = 0;
18781 wxImage *arg1 = (wxImage *) 0 ;
18782 byte arg2 ;
18783 byte arg3 ;
18784 byte arg4 ;
18785 byte arg5 ;
18786 byte arg6 ;
18787 byte arg7 ;
18788 void *argp1 = 0 ;
18789 int res1 = 0 ;
18790 unsigned char val2 ;
18791 int ecode2 = 0 ;
18792 unsigned char val3 ;
18793 int ecode3 = 0 ;
18794 unsigned char val4 ;
18795 int ecode4 = 0 ;
18796 unsigned char val5 ;
18797 int ecode5 = 0 ;
18798 unsigned char val6 ;
18799 int ecode6 = 0 ;
18800 unsigned char val7 ;
18801 int ecode7 = 0 ;
18802 PyObject * obj0 = 0 ;
18803 PyObject * obj1 = 0 ;
18804 PyObject * obj2 = 0 ;
18805 PyObject * obj3 = 0 ;
18806 PyObject * obj4 = 0 ;
18807 PyObject * obj5 = 0 ;
18808 PyObject * obj6 = 0 ;
18809 char * kwnames[] = {
18810 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18811 };
18812
18813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18815 if (!SWIG_IsOK(res1)) {
18816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18817 }
18818 arg1 = reinterpret_cast< wxImage * >(argp1);
18819 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18820 if (!SWIG_IsOK(ecode2)) {
18821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18822 }
18823 arg2 = static_cast< byte >(val2);
18824 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18825 if (!SWIG_IsOK(ecode3)) {
18826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18827 }
18828 arg3 = static_cast< byte >(val3);
18829 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18830 if (!SWIG_IsOK(ecode4)) {
18831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18832 }
18833 arg4 = static_cast< byte >(val4);
18834 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18835 if (!SWIG_IsOK(ecode5)) {
18836 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18837 }
18838 arg5 = static_cast< byte >(val5);
18839 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18840 if (!SWIG_IsOK(ecode6)) {
18841 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18842 }
18843 arg6 = static_cast< byte >(val6);
18844 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18845 if (!SWIG_IsOK(ecode7)) {
18846 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18847 }
18848 arg7 = static_cast< byte >(val7);
18849 {
18850 PyThreadState* __tstate = wxPyBeginAllowThreads();
18851 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18852 wxPyEndAllowThreads(__tstate);
18853 if (PyErr_Occurred()) SWIG_fail;
18854 }
18855 resultobj = SWIG_Py_Void();
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18863 PyObject *resultobj = 0;
18864 wxImage *arg1 = (wxImage *) 0 ;
18865 double arg2 = (double) 0.299 ;
18866 double arg3 = (double) 0.587 ;
18867 double arg4 = (double) 0.114 ;
18868 SwigValueWrapper<wxImage > result;
18869 void *argp1 = 0 ;
18870 int res1 = 0 ;
18871 double val2 ;
18872 int ecode2 = 0 ;
18873 double val3 ;
18874 int ecode3 = 0 ;
18875 double val4 ;
18876 int ecode4 = 0 ;
18877 PyObject * obj0 = 0 ;
18878 PyObject * obj1 = 0 ;
18879 PyObject * obj2 = 0 ;
18880 PyObject * obj3 = 0 ;
18881 char * kwnames[] = {
18882 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18883 };
18884
18885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18887 if (!SWIG_IsOK(res1)) {
18888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18889 }
18890 arg1 = reinterpret_cast< wxImage * >(argp1);
18891 if (obj1) {
18892 ecode2 = SWIG_AsVal_double(obj1, &val2);
18893 if (!SWIG_IsOK(ecode2)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18895 }
18896 arg2 = static_cast< double >(val2);
18897 }
18898 if (obj2) {
18899 ecode3 = SWIG_AsVal_double(obj2, &val3);
18900 if (!SWIG_IsOK(ecode3)) {
18901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18902 }
18903 arg3 = static_cast< double >(val3);
18904 }
18905 if (obj3) {
18906 ecode4 = SWIG_AsVal_double(obj3, &val4);
18907 if (!SWIG_IsOK(ecode4)) {
18908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18909 }
18910 arg4 = static_cast< double >(val4);
18911 }
18912 {
18913 PyThreadState* __tstate = wxPyBeginAllowThreads();
18914 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxImage *arg1 = (wxImage *) 0 ;
18928 byte arg2 ;
18929 byte arg3 ;
18930 byte arg4 ;
18931 SwigValueWrapper<wxImage > result;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 unsigned char val2 ;
18935 int ecode2 = 0 ;
18936 unsigned char val3 ;
18937 int ecode3 = 0 ;
18938 unsigned char val4 ;
18939 int ecode4 = 0 ;
18940 PyObject * obj0 = 0 ;
18941 PyObject * obj1 = 0 ;
18942 PyObject * obj2 = 0 ;
18943 PyObject * obj3 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
18952 }
18953 arg1 = reinterpret_cast< wxImage * >(argp1);
18954 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18955 if (!SWIG_IsOK(ecode2)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
18957 }
18958 arg2 = static_cast< byte >(val2);
18959 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18960 if (!SWIG_IsOK(ecode3)) {
18961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
18962 }
18963 arg3 = static_cast< byte >(val3);
18964 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18965 if (!SWIG_IsOK(ecode4)) {
18966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
18967 }
18968 arg4 = static_cast< byte >(val4);
18969 {
18970 PyThreadState* __tstate = wxPyBeginAllowThreads();
18971 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj = 0;
18984 wxImage *arg1 = (wxImage *) 0 ;
18985 wxString *arg2 = 0 ;
18986 wxString *arg3 = 0 ;
18987 void *argp1 = 0 ;
18988 int res1 = 0 ;
18989 bool temp2 = false ;
18990 bool temp3 = false ;
18991 PyObject * obj0 = 0 ;
18992 PyObject * obj1 = 0 ;
18993 PyObject * obj2 = 0 ;
18994 char * kwnames[] = {
18995 (char *) "self",(char *) "name",(char *) "value", NULL
18996 };
18997
18998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19002 }
19003 arg1 = reinterpret_cast< wxImage * >(argp1);
19004 {
19005 arg2 = wxString_in_helper(obj1);
19006 if (arg2 == NULL) SWIG_fail;
19007 temp2 = true;
19008 }
19009 {
19010 arg3 = wxString_in_helper(obj2);
19011 if (arg3 == NULL) SWIG_fail;
19012 temp3 = true;
19013 }
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 resultobj = SWIG_Py_Void();
19021 {
19022 if (temp2)
19023 delete arg2;
19024 }
19025 {
19026 if (temp3)
19027 delete arg3;
19028 }
19029 return resultobj;
19030 fail:
19031 {
19032 if (temp2)
19033 delete arg2;
19034 }
19035 {
19036 if (temp3)
19037 delete arg3;
19038 }
19039 return NULL;
19040 }
19041
19042
19043 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19044 PyObject *resultobj = 0;
19045 wxImage *arg1 = (wxImage *) 0 ;
19046 wxString *arg2 = 0 ;
19047 int arg3 ;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 bool temp2 = false ;
19051 int val3 ;
19052 int ecode3 = 0 ;
19053 PyObject * obj0 = 0 ;
19054 PyObject * obj1 = 0 ;
19055 PyObject * obj2 = 0 ;
19056 char * kwnames[] = {
19057 (char *) "self",(char *) "name",(char *) "value", NULL
19058 };
19059
19060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19062 if (!SWIG_IsOK(res1)) {
19063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19064 }
19065 arg1 = reinterpret_cast< wxImage * >(argp1);
19066 {
19067 arg2 = wxString_in_helper(obj1);
19068 if (arg2 == NULL) SWIG_fail;
19069 temp2 = true;
19070 }
19071 ecode3 = SWIG_AsVal_int(obj2, &val3);
19072 if (!SWIG_IsOK(ecode3)) {
19073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19074 }
19075 arg3 = static_cast< int >(val3);
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 (arg1)->SetOption((wxString const &)*arg2,arg3);
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_Py_Void();
19083 {
19084 if (temp2)
19085 delete arg2;
19086 }
19087 return resultobj;
19088 fail:
19089 {
19090 if (temp2)
19091 delete arg2;
19092 }
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxImage *arg1 = (wxImage *) 0 ;
19100 wxString *arg2 = 0 ;
19101 wxString result;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 bool temp2 = false ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "name", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19115 }
19116 arg1 = reinterpret_cast< wxImage * >(argp1);
19117 {
19118 arg2 = wxString_in_helper(obj1);
19119 if (arg2 == NULL) SWIG_fail;
19120 temp2 = true;
19121 }
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 #if wxUSE_UNICODE
19130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19131 #else
19132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19133 #endif
19134 }
19135 {
19136 if (temp2)
19137 delete arg2;
19138 }
19139 return resultobj;
19140 fail:
19141 {
19142 if (temp2)
19143 delete arg2;
19144 }
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj = 0;
19151 wxImage *arg1 = (wxImage *) 0 ;
19152 wxString *arg2 = 0 ;
19153 int result;
19154 void *argp1 = 0 ;
19155 int res1 = 0 ;
19156 bool temp2 = false ;
19157 PyObject * obj0 = 0 ;
19158 PyObject * obj1 = 0 ;
19159 char * kwnames[] = {
19160 (char *) "self",(char *) "name", NULL
19161 };
19162
19163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19165 if (!SWIG_IsOK(res1)) {
19166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19167 }
19168 arg1 = reinterpret_cast< wxImage * >(argp1);
19169 {
19170 arg2 = wxString_in_helper(obj1);
19171 if (arg2 == NULL) SWIG_fail;
19172 temp2 = true;
19173 }
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_From_int(static_cast< int >(result));
19181 {
19182 if (temp2)
19183 delete arg2;
19184 }
19185 return resultobj;
19186 fail:
19187 {
19188 if (temp2)
19189 delete arg2;
19190 }
19191 return NULL;
19192 }
19193
19194
19195 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj = 0;
19197 wxImage *arg1 = (wxImage *) 0 ;
19198 wxString *arg2 = 0 ;
19199 bool result;
19200 void *argp1 = 0 ;
19201 int res1 = 0 ;
19202 bool temp2 = false ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char * kwnames[] = {
19206 (char *) "self",(char *) "name", NULL
19207 };
19208
19209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19213 }
19214 arg1 = reinterpret_cast< wxImage * >(argp1);
19215 {
19216 arg2 = wxString_in_helper(obj1);
19217 if (arg2 == NULL) SWIG_fail;
19218 temp2 = true;
19219 }
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19223 wxPyEndAllowThreads(__tstate);
19224 if (PyErr_Occurred()) SWIG_fail;
19225 }
19226 {
19227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19228 }
19229 {
19230 if (temp2)
19231 delete arg2;
19232 }
19233 return resultobj;
19234 fail:
19235 {
19236 if (temp2)
19237 delete arg2;
19238 }
19239 return NULL;
19240 }
19241
19242
19243 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj = 0;
19245 wxImage *arg1 = (wxImage *) 0 ;
19246 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19247 unsigned long result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 unsigned long val2 ;
19251 int ecode2 = 0 ;
19252 PyObject * obj0 = 0 ;
19253 PyObject * obj1 = 0 ;
19254 char * kwnames[] = {
19255 (char *) "self",(char *) "stopafter", NULL
19256 };
19257
19258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19260 if (!SWIG_IsOK(res1)) {
19261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19262 }
19263 arg1 = reinterpret_cast< wxImage * >(argp1);
19264 if (obj1) {
19265 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19266 if (!SWIG_IsOK(ecode2)) {
19267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19268 }
19269 arg2 = static_cast< unsigned long >(val2);
19270 }
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (unsigned long)(arg1)->CountColours(arg2);
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj = 0;
19286 wxImage *arg1 = (wxImage *) 0 ;
19287 wxImageHistogram *arg2 = 0 ;
19288 unsigned long result;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 void *argp2 = 0 ;
19292 int res2 = 0 ;
19293 PyObject * obj0 = 0 ;
19294 PyObject * obj1 = 0 ;
19295 char * kwnames[] = {
19296 (char *) "self",(char *) "h", NULL
19297 };
19298
19299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19303 }
19304 arg1 = reinterpret_cast< wxImage * >(argp1);
19305 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19306 if (!SWIG_IsOK(res2)) {
19307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19308 }
19309 if (!argp2) {
19310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19311 }
19312 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19327 PyObject *resultobj = 0;
19328 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19329 void *argp1 = 0 ;
19330 int res1 = 0 ;
19331 PyObject * obj0 = 0 ;
19332 char * kwnames[] = {
19333 (char *) "handler", NULL
19334 };
19335
19336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19338 if (!SWIG_IsOK(res1)) {
19339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19340 }
19341 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19342 {
19343 PyThreadState* __tstate = wxPyBeginAllowThreads();
19344 wxImage::AddHandler(arg1);
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 resultobj = SWIG_Py_Void();
19349 return resultobj;
19350 fail:
19351 return NULL;
19352 }
19353
19354
19355 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19356 PyObject *resultobj = 0;
19357 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19358 void *argp1 = 0 ;
19359 int res1 = 0 ;
19360 PyObject * obj0 = 0 ;
19361 char * kwnames[] = {
19362 (char *) "handler", NULL
19363 };
19364
19365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19367 if (!SWIG_IsOK(res1)) {
19368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19369 }
19370 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 wxImage::InsertHandler(arg1);
19374 wxPyEndAllowThreads(__tstate);
19375 if (PyErr_Occurred()) SWIG_fail;
19376 }
19377 resultobj = SWIG_Py_Void();
19378 return resultobj;
19379 fail:
19380 return NULL;
19381 }
19382
19383
19384 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19385 PyObject *resultobj = 0;
19386 wxString *arg1 = 0 ;
19387 bool result;
19388 bool temp1 = false ;
19389 PyObject * obj0 = 0 ;
19390 char * kwnames[] = {
19391 (char *) "name", NULL
19392 };
19393
19394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19395 {
19396 arg1 = wxString_in_helper(obj0);
19397 if (arg1 == NULL) SWIG_fail;
19398 temp1 = true;
19399 }
19400 {
19401 PyThreadState* __tstate = wxPyBeginAllowThreads();
19402 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19403 wxPyEndAllowThreads(__tstate);
19404 if (PyErr_Occurred()) SWIG_fail;
19405 }
19406 {
19407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19408 }
19409 {
19410 if (temp1)
19411 delete arg1;
19412 }
19413 return resultobj;
19414 fail:
19415 {
19416 if (temp1)
19417 delete arg1;
19418 }
19419 return NULL;
19420 }
19421
19422
19423 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19424 PyObject *resultobj = 0;
19425 PyObject *result = 0 ;
19426
19427 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19428 {
19429 PyThreadState* __tstate = wxPyBeginAllowThreads();
19430 result = (PyObject *)wxImage_GetHandlers();
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 resultobj = result;
19435 return resultobj;
19436 fail:
19437 return NULL;
19438 }
19439
19440
19441 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19442 PyObject *resultobj = 0;
19443 wxString result;
19444
19445 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 result = wxImage::GetImageExtWildcard();
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 {
19453 #if wxUSE_UNICODE
19454 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19455 #else
19456 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19457 #endif
19458 }
19459 return resultobj;
19460 fail:
19461 return NULL;
19462 }
19463
19464
19465 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj = 0;
19467 wxImage *arg1 = (wxImage *) 0 ;
19468 int arg2 = (int) -1 ;
19469 wxBitmap result;
19470 void *argp1 = 0 ;
19471 int res1 = 0 ;
19472 int val2 ;
19473 int ecode2 = 0 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 char * kwnames[] = {
19477 (char *) "self",(char *) "depth", NULL
19478 };
19479
19480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19482 if (!SWIG_IsOK(res1)) {
19483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19484 }
19485 arg1 = reinterpret_cast< wxImage * >(argp1);
19486 if (obj1) {
19487 ecode2 = SWIG_AsVal_int(obj1, &val2);
19488 if (!SWIG_IsOK(ecode2)) {
19489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19490 }
19491 arg2 = static_cast< int >(val2);
19492 }
19493 {
19494 if (!wxPyCheckForApp()) SWIG_fail;
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = wxImage_ConvertToBitmap(arg1,arg2);
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj = 0;
19509 wxImage *arg1 = (wxImage *) 0 ;
19510 byte arg2 ;
19511 byte arg3 ;
19512 byte arg4 ;
19513 wxBitmap result;
19514 void *argp1 = 0 ;
19515 int res1 = 0 ;
19516 unsigned char val2 ;
19517 int ecode2 = 0 ;
19518 unsigned char val3 ;
19519 int ecode3 = 0 ;
19520 unsigned char val4 ;
19521 int ecode4 = 0 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 PyObject * obj2 = 0 ;
19525 PyObject * obj3 = 0 ;
19526 char * kwnames[] = {
19527 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19528 };
19529
19530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19532 if (!SWIG_IsOK(res1)) {
19533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19534 }
19535 arg1 = reinterpret_cast< wxImage * >(argp1);
19536 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19537 if (!SWIG_IsOK(ecode2)) {
19538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19539 }
19540 arg2 = static_cast< byte >(val2);
19541 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19542 if (!SWIG_IsOK(ecode3)) {
19543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19544 }
19545 arg3 = static_cast< byte >(val3);
19546 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19547 if (!SWIG_IsOK(ecode4)) {
19548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19549 }
19550 arg4 = static_cast< byte >(val4);
19551 {
19552 if (!wxPyCheckForApp()) SWIG_fail;
19553 PyThreadState* __tstate = wxPyBeginAllowThreads();
19554 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19555 wxPyEndAllowThreads(__tstate);
19556 if (PyErr_Occurred()) SWIG_fail;
19557 }
19558 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj = 0;
19567 wxImage *arg1 = (wxImage *) 0 ;
19568 double arg2 ;
19569 void *argp1 = 0 ;
19570 int res1 = 0 ;
19571 double val2 ;
19572 int ecode2 = 0 ;
19573 PyObject * obj0 = 0 ;
19574 PyObject * obj1 = 0 ;
19575 char * kwnames[] = {
19576 (char *) "self",(char *) "angle", NULL
19577 };
19578
19579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19581 if (!SWIG_IsOK(res1)) {
19582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19583 }
19584 arg1 = reinterpret_cast< wxImage * >(argp1);
19585 ecode2 = SWIG_AsVal_double(obj1, &val2);
19586 if (!SWIG_IsOK(ecode2)) {
19587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19588 }
19589 arg2 = static_cast< double >(val2);
19590 {
19591 PyThreadState* __tstate = wxPyBeginAllowThreads();
19592 (arg1)->RotateHue(arg2);
19593 wxPyEndAllowThreads(__tstate);
19594 if (PyErr_Occurred()) SWIG_fail;
19595 }
19596 resultobj = SWIG_Py_Void();
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj = 0;
19605 wxImage_RGBValue arg1 ;
19606 wxImage_HSVValue result;
19607 void *argp1 ;
19608 int res1 = 0 ;
19609 PyObject * obj0 = 0 ;
19610 char * kwnames[] = {
19611 (char *) "rgb", NULL
19612 };
19613
19614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19615 {
19616 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19617 if (!SWIG_IsOK(res1)) {
19618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19619 }
19620 if (!argp1) {
19621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19622 } else {
19623 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19624 arg1 = *temp;
19625 if (SWIG_IsNewObj(res1)) delete temp;
19626 }
19627 }
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = wxImage::RGBtoHSV(arg1);
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj = 0;
19643 wxImage_HSVValue arg1 ;
19644 wxImage_RGBValue result;
19645 void *argp1 ;
19646 int res1 = 0 ;
19647 PyObject * obj0 = 0 ;
19648 char * kwnames[] = {
19649 (char *) "hsv", NULL
19650 };
19651
19652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19653 {
19654 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19655 if (!SWIG_IsOK(res1)) {
19656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19657 }
19658 if (!argp1) {
19659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19660 } else {
19661 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19662 arg1 = *temp;
19663 if (SWIG_IsNewObj(res1)) delete temp;
19664 }
19665 }
19666 {
19667 PyThreadState* __tstate = wxPyBeginAllowThreads();
19668 result = wxImage::HSVtoRGB(arg1);
19669 wxPyEndAllowThreads(__tstate);
19670 if (PyErr_Occurred()) SWIG_fail;
19671 }
19672 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19680 PyObject *obj;
19681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19682 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19683 return SWIG_Py_Void();
19684 }
19685
19686 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19687 return SWIG_Python_InitShadowInstance(args);
19688 }
19689
19690 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19691 PyObject *resultobj = 0;
19692 int arg1 ;
19693 int arg2 ;
19694 buffer arg3 ;
19695 int arg4 ;
19696 buffer arg5 = (buffer) NULL ;
19697 int arg6 = (int) 0 ;
19698 wxImage *result = 0 ;
19699 int val1 ;
19700 int ecode1 = 0 ;
19701 int val2 ;
19702 int ecode2 = 0 ;
19703 Py_ssize_t temp3 ;
19704 Py_ssize_t temp5 ;
19705 PyObject * obj0 = 0 ;
19706 PyObject * obj1 = 0 ;
19707 PyObject * obj2 = 0 ;
19708 PyObject * obj3 = 0 ;
19709 char * kwnames[] = {
19710 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19711 };
19712
19713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19714 ecode1 = SWIG_AsVal_int(obj0, &val1);
19715 if (!SWIG_IsOK(ecode1)) {
19716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19717 }
19718 arg1 = static_cast< int >(val1);
19719 ecode2 = SWIG_AsVal_int(obj1, &val2);
19720 if (!SWIG_IsOK(ecode2)) {
19721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19722 }
19723 arg2 = static_cast< int >(val2);
19724 {
19725 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19726 arg4 = (int)temp3;
19727 }
19728 if (obj3) {
19729 {
19730 if (obj3 != Py_None) {
19731 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19732 arg6 = (int)temp5;
19733 }
19734 }
19735 }
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 {
19743 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19744 }
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 SWIGINTERN int NullImage_set(PyObject *) {
19752 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19753 return 1;
19754 }
19755
19756
19757 SWIGINTERN PyObject *NullImage_get(void) {
19758 PyObject *pyobj = 0;
19759
19760 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19761 return pyobj;
19762 }
19763
19764
19765 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19766 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19767 return 1;
19768 }
19769
19770
19771 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19772 PyObject *pyobj = 0;
19773
19774 {
19775 #if wxUSE_UNICODE
19776 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19777 #else
19778 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19779 #endif
19780 }
19781 return pyobj;
19782 }
19783
19784
19785 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19786 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19787 return 1;
19788 }
19789
19790
19791 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19792 PyObject *pyobj = 0;
19793
19794 {
19795 #if wxUSE_UNICODE
19796 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19797 #else
19798 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19799 #endif
19800 }
19801 return pyobj;
19802 }
19803
19804
19805 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19806 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19807 return 1;
19808 }
19809
19810
19811 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19812 PyObject *pyobj = 0;
19813
19814 {
19815 #if wxUSE_UNICODE
19816 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19817 #else
19818 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19819 #endif
19820 }
19821 return pyobj;
19822 }
19823
19824
19825 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19826 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19827 return 1;
19828 }
19829
19830
19831 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19832 PyObject *pyobj = 0;
19833
19834 {
19835 #if wxUSE_UNICODE
19836 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19837 #else
19838 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19839 #endif
19840 }
19841 return pyobj;
19842 }
19843
19844
19845 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19846 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19847 return 1;
19848 }
19849
19850
19851 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19852 PyObject *pyobj = 0;
19853
19854 {
19855 #if wxUSE_UNICODE
19856 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19857 #else
19858 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19859 #endif
19860 }
19861 return pyobj;
19862 }
19863
19864
19865 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19866 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19867 return 1;
19868 }
19869
19870
19871 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19872 PyObject *pyobj = 0;
19873
19874 {
19875 #if wxUSE_UNICODE
19876 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19877 #else
19878 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19879 #endif
19880 }
19881 return pyobj;
19882 }
19883
19884
19885 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 {
19895 #if wxUSE_UNICODE
19896 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19897 #else
19898 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19899 #endif
19900 }
19901 return pyobj;
19902 }
19903
19904
19905 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19906 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19907 return 1;
19908 }
19909
19910
19911 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19912 PyObject *pyobj = 0;
19913
19914 {
19915 #if wxUSE_UNICODE
19916 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19917 #else
19918 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19919 #endif
19920 }
19921 return pyobj;
19922 }
19923
19924
19925 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19926 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19927 return 1;
19928 }
19929
19930
19931 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19932 PyObject *pyobj = 0;
19933
19934 {
19935 #if wxUSE_UNICODE
19936 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19937 #else
19938 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19939 #endif
19940 }
19941 return pyobj;
19942 }
19943
19944
19945 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19946 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19947 return 1;
19948 }
19949
19950
19951 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
19952 PyObject *pyobj = 0;
19953
19954 {
19955 #if wxUSE_UNICODE
19956 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
19957 #else
19958 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
19959 #endif
19960 }
19961 return pyobj;
19962 }
19963
19964
19965 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
19966 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
19967 return 1;
19968 }
19969
19970
19971 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
19972 PyObject *pyobj = 0;
19973
19974 {
19975 #if wxUSE_UNICODE
19976 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
19977 #else
19978 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
19979 #endif
19980 }
19981 return pyobj;
19982 }
19983
19984
19985 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
19986 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
19987 return 1;
19988 }
19989
19990
19991 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
19992 PyObject *pyobj = 0;
19993
19994 {
19995 #if wxUSE_UNICODE
19996 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
19997 #else
19998 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
19999 #endif
20000 }
20001 return pyobj;
20002 }
20003
20004
20005 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20006 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20007 return 1;
20008 }
20009
20010
20011 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20012 PyObject *pyobj = 0;
20013
20014 {
20015 #if wxUSE_UNICODE
20016 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20017 #else
20018 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20019 #endif
20020 }
20021 return pyobj;
20022 }
20023
20024
20025 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20026 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20027 return 1;
20028 }
20029
20030
20031 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20032 PyObject *pyobj = 0;
20033
20034 {
20035 #if wxUSE_UNICODE
20036 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20037 #else
20038 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20039 #endif
20040 }
20041 return pyobj;
20042 }
20043
20044
20045 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20046 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20047 return 1;
20048 }
20049
20050
20051 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20052 PyObject *pyobj = 0;
20053
20054 {
20055 #if wxUSE_UNICODE
20056 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20057 #else
20058 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20059 #endif
20060 }
20061 return pyobj;
20062 }
20063
20064
20065 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20066 PyObject *resultobj = 0;
20067 wxBMPHandler *result = 0 ;
20068
20069 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20070 {
20071 PyThreadState* __tstate = wxPyBeginAllowThreads();
20072 result = (wxBMPHandler *)new wxBMPHandler();
20073 wxPyEndAllowThreads(__tstate);
20074 if (PyErr_Occurred()) SWIG_fail;
20075 }
20076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 PyObject *obj;
20085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20086 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20087 return SWIG_Py_Void();
20088 }
20089
20090 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20091 return SWIG_Python_InitShadowInstance(args);
20092 }
20093
20094 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20095 PyObject *resultobj = 0;
20096 wxICOHandler *result = 0 ;
20097
20098 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20099 {
20100 PyThreadState* __tstate = wxPyBeginAllowThreads();
20101 result = (wxICOHandler *)new wxICOHandler();
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20113 PyObject *obj;
20114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20115 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20116 return SWIG_Py_Void();
20117 }
20118
20119 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20120 return SWIG_Python_InitShadowInstance(args);
20121 }
20122
20123 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20124 PyObject *resultobj = 0;
20125 wxCURHandler *result = 0 ;
20126
20127 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 result = (wxCURHandler *)new wxCURHandler();
20131 wxPyEndAllowThreads(__tstate);
20132 if (PyErr_Occurred()) SWIG_fail;
20133 }
20134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20135 return resultobj;
20136 fail:
20137 return NULL;
20138 }
20139
20140
20141 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20142 PyObject *obj;
20143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20144 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20145 return SWIG_Py_Void();
20146 }
20147
20148 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20149 return SWIG_Python_InitShadowInstance(args);
20150 }
20151
20152 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20153 PyObject *resultobj = 0;
20154 wxANIHandler *result = 0 ;
20155
20156 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20157 {
20158 PyThreadState* __tstate = wxPyBeginAllowThreads();
20159 result = (wxANIHandler *)new wxANIHandler();
20160 wxPyEndAllowThreads(__tstate);
20161 if (PyErr_Occurred()) SWIG_fail;
20162 }
20163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20171 PyObject *obj;
20172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20173 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20174 return SWIG_Py_Void();
20175 }
20176
20177 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20178 return SWIG_Python_InitShadowInstance(args);
20179 }
20180
20181 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20182 PyObject *resultobj = 0;
20183 wxPNGHandler *result = 0 ;
20184
20185 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 result = (wxPNGHandler *)new wxPNGHandler();
20189 wxPyEndAllowThreads(__tstate);
20190 if (PyErr_Occurred()) SWIG_fail;
20191 }
20192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20193 return resultobj;
20194 fail:
20195 return NULL;
20196 }
20197
20198
20199 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20200 PyObject *obj;
20201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20202 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20203 return SWIG_Py_Void();
20204 }
20205
20206 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20207 return SWIG_Python_InitShadowInstance(args);
20208 }
20209
20210 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20211 PyObject *resultobj = 0;
20212 wxGIFHandler *result = 0 ;
20213
20214 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20215 {
20216 PyThreadState* __tstate = wxPyBeginAllowThreads();
20217 result = (wxGIFHandler *)new wxGIFHandler();
20218 wxPyEndAllowThreads(__tstate);
20219 if (PyErr_Occurred()) SWIG_fail;
20220 }
20221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20222 return resultobj;
20223 fail:
20224 return NULL;
20225 }
20226
20227
20228 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20229 PyObject *obj;
20230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20231 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20232 return SWIG_Py_Void();
20233 }
20234
20235 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20236 return SWIG_Python_InitShadowInstance(args);
20237 }
20238
20239 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *resultobj = 0;
20241 wxPCXHandler *result = 0 ;
20242
20243 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 result = (wxPCXHandler *)new wxPCXHandler();
20247 wxPyEndAllowThreads(__tstate);
20248 if (PyErr_Occurred()) SWIG_fail;
20249 }
20250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20251 return resultobj;
20252 fail:
20253 return NULL;
20254 }
20255
20256
20257 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 PyObject *obj;
20259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20260 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20261 return SWIG_Py_Void();
20262 }
20263
20264 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20265 return SWIG_Python_InitShadowInstance(args);
20266 }
20267
20268 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20269 PyObject *resultobj = 0;
20270 wxJPEGHandler *result = 0 ;
20271
20272 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20273 {
20274 PyThreadState* __tstate = wxPyBeginAllowThreads();
20275 result = (wxJPEGHandler *)new wxJPEGHandler();
20276 wxPyEndAllowThreads(__tstate);
20277 if (PyErr_Occurred()) SWIG_fail;
20278 }
20279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20280 return resultobj;
20281 fail:
20282 return NULL;
20283 }
20284
20285
20286 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20287 PyObject *obj;
20288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20289 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20290 return SWIG_Py_Void();
20291 }
20292
20293 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20294 return SWIG_Python_InitShadowInstance(args);
20295 }
20296
20297 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20298 PyObject *resultobj = 0;
20299 wxPNMHandler *result = 0 ;
20300
20301 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20302 {
20303 PyThreadState* __tstate = wxPyBeginAllowThreads();
20304 result = (wxPNMHandler *)new wxPNMHandler();
20305 wxPyEndAllowThreads(__tstate);
20306 if (PyErr_Occurred()) SWIG_fail;
20307 }
20308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20309 return resultobj;
20310 fail:
20311 return NULL;
20312 }
20313
20314
20315 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20316 PyObject *obj;
20317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20318 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20319 return SWIG_Py_Void();
20320 }
20321
20322 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20323 return SWIG_Python_InitShadowInstance(args);
20324 }
20325
20326 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20327 PyObject *resultobj = 0;
20328 wxXPMHandler *result = 0 ;
20329
20330 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (wxXPMHandler *)new wxXPMHandler();
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *obj;
20346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20347 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20348 return SWIG_Py_Void();
20349 }
20350
20351 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20352 return SWIG_Python_InitShadowInstance(args);
20353 }
20354
20355 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 PyObject *resultobj = 0;
20357 wxTIFFHandler *result = 0 ;
20358
20359 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20360 {
20361 PyThreadState* __tstate = wxPyBeginAllowThreads();
20362 result = (wxTIFFHandler *)new wxTIFFHandler();
20363 wxPyEndAllowThreads(__tstate);
20364 if (PyErr_Occurred()) SWIG_fail;
20365 }
20366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20374 PyObject *obj;
20375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20376 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20377 return SWIG_Py_Void();
20378 }
20379
20380 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20381 return SWIG_Python_InitShadowInstance(args);
20382 }
20383
20384 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj = 0;
20386 wxImage *arg1 = 0 ;
20387 wxImage *arg2 = 0 ;
20388 int arg3 = (int) 236 ;
20389 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20390 bool result;
20391 void *argp1 = 0 ;
20392 int res1 = 0 ;
20393 void *argp2 = 0 ;
20394 int res2 = 0 ;
20395 int val3 ;
20396 int ecode3 = 0 ;
20397 int val4 ;
20398 int ecode4 = 0 ;
20399 PyObject * obj0 = 0 ;
20400 PyObject * obj1 = 0 ;
20401 PyObject * obj2 = 0 ;
20402 PyObject * obj3 = 0 ;
20403 char * kwnames[] = {
20404 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20405 };
20406
20407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20408 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20409 if (!SWIG_IsOK(res1)) {
20410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20411 }
20412 if (!argp1) {
20413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20414 }
20415 arg1 = reinterpret_cast< wxImage * >(argp1);
20416 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20417 if (!SWIG_IsOK(res2)) {
20418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20419 }
20420 if (!argp2) {
20421 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20422 }
20423 arg2 = reinterpret_cast< wxImage * >(argp2);
20424 if (obj2) {
20425 ecode3 = SWIG_AsVal_int(obj2, &val3);
20426 if (!SWIG_IsOK(ecode3)) {
20427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20428 }
20429 arg3 = static_cast< int >(val3);
20430 }
20431 if (obj3) {
20432 ecode4 = SWIG_AsVal_int(obj3, &val4);
20433 if (!SWIG_IsOK(ecode4)) {
20434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20435 }
20436 arg4 = static_cast< int >(val4);
20437 }
20438 {
20439 PyThreadState* __tstate = wxPyBeginAllowThreads();
20440 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 {
20445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20446 }
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20454 PyObject *obj;
20455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20456 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20457 return SWIG_Py_Void();
20458 }
20459
20460 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20461 PyObject *resultobj = 0;
20462 wxEvtHandler *result = 0 ;
20463
20464 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20465 {
20466 PyThreadState* __tstate = wxPyBeginAllowThreads();
20467 result = (wxEvtHandler *)new wxEvtHandler();
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20472 return resultobj;
20473 fail:
20474 return NULL;
20475 }
20476
20477
20478 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20479 PyObject *resultobj = 0;
20480 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20481 wxEvtHandler *result = 0 ;
20482 void *argp1 = 0 ;
20483 int res1 = 0 ;
20484 PyObject *swig_obj[1] ;
20485
20486 if (!args) SWIG_fail;
20487 swig_obj[0] = args;
20488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20489 if (!SWIG_IsOK(res1)) {
20490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20491 }
20492 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20496 wxPyEndAllowThreads(__tstate);
20497 if (PyErr_Occurred()) SWIG_fail;
20498 }
20499 {
20500 resultobj = wxPyMake_wxObject(result, 0);
20501 }
20502 return resultobj;
20503 fail:
20504 return NULL;
20505 }
20506
20507
20508 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20509 PyObject *resultobj = 0;
20510 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20511 wxEvtHandler *result = 0 ;
20512 void *argp1 = 0 ;
20513 int res1 = 0 ;
20514 PyObject *swig_obj[1] ;
20515
20516 if (!args) SWIG_fail;
20517 swig_obj[0] = args;
20518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20519 if (!SWIG_IsOK(res1)) {
20520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20521 }
20522 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 {
20530 resultobj = wxPyMake_wxObject(result, 0);
20531 }
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj = 0;
20540 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20541 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20542 void *argp1 = 0 ;
20543 int res1 = 0 ;
20544 void *argp2 = 0 ;
20545 int res2 = 0 ;
20546 PyObject * obj0 = 0 ;
20547 PyObject * obj1 = 0 ;
20548 char * kwnames[] = {
20549 (char *) "self",(char *) "handler", NULL
20550 };
20551
20552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20554 if (!SWIG_IsOK(res1)) {
20555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20556 }
20557 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20559 if (!SWIG_IsOK(res2)) {
20560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20561 }
20562 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 (arg1)->SetNextHandler(arg2);
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 resultobj = SWIG_Py_Void();
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20577 PyObject *resultobj = 0;
20578 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20579 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20580 void *argp1 = 0 ;
20581 int res1 = 0 ;
20582 void *argp2 = 0 ;
20583 int res2 = 0 ;
20584 PyObject * obj0 = 0 ;
20585 PyObject * obj1 = 0 ;
20586 char * kwnames[] = {
20587 (char *) "self",(char *) "handler", NULL
20588 };
20589
20590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20594 }
20595 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20596 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20597 if (!SWIG_IsOK(res2)) {
20598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20599 }
20600 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 (arg1)->SetPreviousHandler(arg2);
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 resultobj = SWIG_Py_Void();
20608 return resultobj;
20609 fail:
20610 return NULL;
20611 }
20612
20613
20614 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20615 PyObject *resultobj = 0;
20616 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20617 bool result;
20618 void *argp1 = 0 ;
20619 int res1 = 0 ;
20620 PyObject *swig_obj[1] ;
20621
20622 if (!args) SWIG_fail;
20623 swig_obj[0] = args;
20624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20627 }
20628 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (bool)(arg1)->GetEvtHandlerEnabled();
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 {
20636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20637 }
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20645 PyObject *resultobj = 0;
20646 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20647 bool arg2 ;
20648 void *argp1 = 0 ;
20649 int res1 = 0 ;
20650 bool val2 ;
20651 int ecode2 = 0 ;
20652 PyObject * obj0 = 0 ;
20653 PyObject * obj1 = 0 ;
20654 char * kwnames[] = {
20655 (char *) "self",(char *) "enabled", NULL
20656 };
20657
20658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20660 if (!SWIG_IsOK(res1)) {
20661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20662 }
20663 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20665 if (!SWIG_IsOK(ecode2)) {
20666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20667 }
20668 arg2 = static_cast< bool >(val2);
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 (arg1)->SetEvtHandlerEnabled(arg2);
20672 wxPyEndAllowThreads(__tstate);
20673 if (PyErr_Occurred()) SWIG_fail;
20674 }
20675 resultobj = SWIG_Py_Void();
20676 return resultobj;
20677 fail:
20678 return NULL;
20679 }
20680
20681
20682 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20683 PyObject *resultobj = 0;
20684 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20685 wxEvent *arg2 = 0 ;
20686 bool result;
20687 void *argp1 = 0 ;
20688 int res1 = 0 ;
20689 void *argp2 = 0 ;
20690 int res2 = 0 ;
20691 PyObject * obj0 = 0 ;
20692 PyObject * obj1 = 0 ;
20693 char * kwnames[] = {
20694 (char *) "self",(char *) "event", NULL
20695 };
20696
20697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20699 if (!SWIG_IsOK(res1)) {
20700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20701 }
20702 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20703 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20704 if (!SWIG_IsOK(res2)) {
20705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20706 }
20707 if (!argp2) {
20708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20709 }
20710 arg2 = reinterpret_cast< wxEvent * >(argp2);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)(arg1)->ProcessEvent(*arg2);
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj = 0;
20728 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20729 wxEvent *arg2 = 0 ;
20730 void *argp1 = 0 ;
20731 int res1 = 0 ;
20732 void *argp2 = 0 ;
20733 int res2 = 0 ;
20734 PyObject * obj0 = 0 ;
20735 PyObject * obj1 = 0 ;
20736 char * kwnames[] = {
20737 (char *) "self",(char *) "event", NULL
20738 };
20739
20740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20742 if (!SWIG_IsOK(res1)) {
20743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20744 }
20745 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20746 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20747 if (!SWIG_IsOK(res2)) {
20748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20749 }
20750 if (!argp2) {
20751 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20752 }
20753 arg2 = reinterpret_cast< wxEvent * >(argp2);
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 (arg1)->AddPendingEvent(*arg2);
20757 wxPyEndAllowThreads(__tstate);
20758 if (PyErr_Occurred()) SWIG_fail;
20759 }
20760 resultobj = SWIG_Py_Void();
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20768 PyObject *resultobj = 0;
20769 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20770 void *argp1 = 0 ;
20771 int res1 = 0 ;
20772 PyObject *swig_obj[1] ;
20773
20774 if (!args) SWIG_fail;
20775 swig_obj[0] = args;
20776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20777 if (!SWIG_IsOK(res1)) {
20778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20779 }
20780 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20781 {
20782 PyThreadState* __tstate = wxPyBeginAllowThreads();
20783 (arg1)->ProcessPendingEvents();
20784 wxPyEndAllowThreads(__tstate);
20785 if (PyErr_Occurred()) SWIG_fail;
20786 }
20787 resultobj = SWIG_Py_Void();
20788 return resultobj;
20789 fail:
20790 return NULL;
20791 }
20792
20793
20794 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20795 PyObject *resultobj = 0;
20796 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20797 bool arg2 = (bool) true ;
20798 void *argp1 = 0 ;
20799 int res1 = 0 ;
20800 bool val2 ;
20801 int ecode2 = 0 ;
20802 PyObject * obj0 = 0 ;
20803 PyObject * obj1 = 0 ;
20804 char * kwnames[] = {
20805 (char *) "self",(char *) "allow", NULL
20806 };
20807
20808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20810 if (!SWIG_IsOK(res1)) {
20811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20812 }
20813 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20814 if (obj1) {
20815 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20816 if (!SWIG_IsOK(ecode2)) {
20817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20818 }
20819 arg2 = static_cast< bool >(val2);
20820 }
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 (arg1)->AllowReentrance(arg2);
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 resultobj = SWIG_Py_Void();
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 PyObject *resultobj = 0;
20836 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20837 bool result;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 PyObject *swig_obj[1] ;
20841
20842 if (!args) SWIG_fail;
20843 swig_obj[0] = args;
20844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20845 if (!SWIG_IsOK(res1)) {
20846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20847 }
20848 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (bool)(arg1)->IsReentranceAllowed();
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 {
20856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20857 }
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20865 PyObject *resultobj = 0;
20866 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20867 bool result;
20868 void *argp1 = 0 ;
20869 int res1 = 0 ;
20870 PyObject *swig_obj[1] ;
20871
20872 if (!args) SWIG_fail;
20873 swig_obj[0] = args;
20874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20875 if (!SWIG_IsOK(res1)) {
20876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20877 }
20878 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 result = (bool)(arg1)->IsEventHandlingInProgress();
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 {
20886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20887 }
20888 return resultobj;
20889 fail:
20890 return NULL;
20891 }
20892
20893
20894 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20895 PyObject *resultobj = 0;
20896 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20897 int arg2 ;
20898 int arg3 ;
20899 int arg4 ;
20900 PyObject *arg5 = (PyObject *) 0 ;
20901 void *argp1 = 0 ;
20902 int res1 = 0 ;
20903 int val2 ;
20904 int ecode2 = 0 ;
20905 int val3 ;
20906 int ecode3 = 0 ;
20907 int val4 ;
20908 int ecode4 = 0 ;
20909 PyObject * obj0 = 0 ;
20910 PyObject * obj1 = 0 ;
20911 PyObject * obj2 = 0 ;
20912 PyObject * obj3 = 0 ;
20913 PyObject * obj4 = 0 ;
20914 char * kwnames[] = {
20915 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20916 };
20917
20918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20920 if (!SWIG_IsOK(res1)) {
20921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20922 }
20923 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20924 ecode2 = SWIG_AsVal_int(obj1, &val2);
20925 if (!SWIG_IsOK(ecode2)) {
20926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20927 }
20928 arg2 = static_cast< int >(val2);
20929 ecode3 = SWIG_AsVal_int(obj2, &val3);
20930 if (!SWIG_IsOK(ecode3)) {
20931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20932 }
20933 arg3 = static_cast< int >(val3);
20934 ecode4 = SWIG_AsVal_int(obj3, &val4);
20935 if (!SWIG_IsOK(ecode4)) {
20936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20937 }
20938 arg4 = static_cast< int >(val4);
20939 arg5 = obj4;
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_Py_Void();
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20954 PyObject *resultobj = 0;
20955 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20956 int arg2 ;
20957 int arg3 = (int) -1 ;
20958 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20959 bool result;
20960 void *argp1 = 0 ;
20961 int res1 = 0 ;
20962 int val2 ;
20963 int ecode2 = 0 ;
20964 int val3 ;
20965 int ecode3 = 0 ;
20966 int val4 ;
20967 int ecode4 = 0 ;
20968 PyObject * obj0 = 0 ;
20969 PyObject * obj1 = 0 ;
20970 PyObject * obj2 = 0 ;
20971 PyObject * obj3 = 0 ;
20972 char * kwnames[] = {
20973 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20974 };
20975
20976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20978 if (!SWIG_IsOK(res1)) {
20979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20980 }
20981 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20982 ecode2 = SWIG_AsVal_int(obj1, &val2);
20983 if (!SWIG_IsOK(ecode2)) {
20984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20985 }
20986 arg2 = static_cast< int >(val2);
20987 if (obj2) {
20988 ecode3 = SWIG_AsVal_int(obj2, &val3);
20989 if (!SWIG_IsOK(ecode3)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20991 }
20992 arg3 = static_cast< int >(val3);
20993 }
20994 if (obj3) {
20995 ecode4 = SWIG_AsVal_int(obj3, &val4);
20996 if (!SWIG_IsOK(ecode4)) {
20997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20998 }
20999 arg4 = static_cast< wxEventType >(val4);
21000 }
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 {
21008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21009 }
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj = 0;
21018 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21019 PyObject *arg2 = (PyObject *) 0 ;
21020 bool arg3 = (bool) true ;
21021 void *argp1 = 0 ;
21022 int res1 = 0 ;
21023 bool val3 ;
21024 int ecode3 = 0 ;
21025 PyObject * obj0 = 0 ;
21026 PyObject * obj1 = 0 ;
21027 PyObject * obj2 = 0 ;
21028 char * kwnames[] = {
21029 (char *) "self",(char *) "_self",(char *) "incref", NULL
21030 };
21031
21032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21034 if (!SWIG_IsOK(res1)) {
21035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21036 }
21037 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21038 arg2 = obj1;
21039 if (obj2) {
21040 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21041 if (!SWIG_IsOK(ecode3)) {
21042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21043 }
21044 arg3 = static_cast< bool >(val3);
21045 }
21046 {
21047 PyThreadState* __tstate = wxPyBeginAllowThreads();
21048 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 resultobj = SWIG_Py_Void();
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 PyObject *obj;
21061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21062 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21063 return SWIG_Py_Void();
21064 }
21065
21066 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21067 return SWIG_Python_InitShadowInstance(args);
21068 }
21069
21070 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21071 PyObject *resultobj = 0;
21072 wxEventType result;
21073
21074 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (wxEventType)wxNewEventType();
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 resultobj = SWIG_From_int(static_cast< int >(result));
21082 return resultobj;
21083 fail:
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21089 PyObject *resultobj = 0;
21090 wxEvent *arg1 = (wxEvent *) 0 ;
21091 void *argp1 = 0 ;
21092 int res1 = 0 ;
21093 PyObject *swig_obj[1] ;
21094
21095 if (!args) SWIG_fail;
21096 swig_obj[0] = args;
21097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21098 if (!SWIG_IsOK(res1)) {
21099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21100 }
21101 arg1 = reinterpret_cast< wxEvent * >(argp1);
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 delete arg1;
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 resultobj = SWIG_Py_Void();
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21117 PyObject *resultobj = 0;
21118 wxEvent *arg1 = (wxEvent *) 0 ;
21119 wxEventType arg2 ;
21120 void *argp1 = 0 ;
21121 int res1 = 0 ;
21122 int val2 ;
21123 int ecode2 = 0 ;
21124 PyObject * obj0 = 0 ;
21125 PyObject * obj1 = 0 ;
21126 char * kwnames[] = {
21127 (char *) "self",(char *) "typ", NULL
21128 };
21129
21130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21132 if (!SWIG_IsOK(res1)) {
21133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21134 }
21135 arg1 = reinterpret_cast< wxEvent * >(argp1);
21136 ecode2 = SWIG_AsVal_int(obj1, &val2);
21137 if (!SWIG_IsOK(ecode2)) {
21138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21139 }
21140 arg2 = static_cast< wxEventType >(val2);
21141 {
21142 PyThreadState* __tstate = wxPyBeginAllowThreads();
21143 (arg1)->SetEventType(arg2);
21144 wxPyEndAllowThreads(__tstate);
21145 if (PyErr_Occurred()) SWIG_fail;
21146 }
21147 resultobj = SWIG_Py_Void();
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 PyObject *resultobj = 0;
21156 wxEvent *arg1 = (wxEvent *) 0 ;
21157 wxEventType result;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 PyObject *swig_obj[1] ;
21161
21162 if (!args) SWIG_fail;
21163 swig_obj[0] = args;
21164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21165 if (!SWIG_IsOK(res1)) {
21166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21167 }
21168 arg1 = reinterpret_cast< wxEvent * >(argp1);
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 resultobj = SWIG_From_int(static_cast< int >(result));
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxEvent *arg1 = (wxEvent *) 0 ;
21185 wxObject *result = 0 ;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 PyObject *swig_obj[1] ;
21189
21190 if (!args) SWIG_fail;
21191 swig_obj[0] = args;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21195 }
21196 arg1 = reinterpret_cast< wxEvent * >(argp1);
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 {
21204 resultobj = wxPyMake_wxObject(result, (bool)0);
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21213 PyObject *resultobj = 0;
21214 wxEvent *arg1 = (wxEvent *) 0 ;
21215 wxObject *arg2 = (wxObject *) 0 ;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 void *argp2 = 0 ;
21219 int res2 = 0 ;
21220 PyObject * obj0 = 0 ;
21221 PyObject * obj1 = 0 ;
21222 char * kwnames[] = {
21223 (char *) "self",(char *) "obj", NULL
21224 };
21225
21226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21230 }
21231 arg1 = reinterpret_cast< wxEvent * >(argp1);
21232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21233 if (!SWIG_IsOK(res2)) {
21234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21235 }
21236 arg2 = reinterpret_cast< wxObject * >(argp2);
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 (arg1)->SetEventObject(arg2);
21240 wxPyEndAllowThreads(__tstate);
21241 if (PyErr_Occurred()) SWIG_fail;
21242 }
21243 resultobj = SWIG_Py_Void();
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21251 PyObject *resultobj = 0;
21252 wxEvent *arg1 = (wxEvent *) 0 ;
21253 long result;
21254 void *argp1 = 0 ;
21255 int res1 = 0 ;
21256 PyObject *swig_obj[1] ;
21257
21258 if (!args) SWIG_fail;
21259 swig_obj[0] = args;
21260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21261 if (!SWIG_IsOK(res1)) {
21262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21263 }
21264 arg1 = reinterpret_cast< wxEvent * >(argp1);
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 resultobj = SWIG_From_long(static_cast< long >(result));
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj = 0;
21280 wxEvent *arg1 = (wxEvent *) 0 ;
21281 long arg2 = (long) 0 ;
21282 void *argp1 = 0 ;
21283 int res1 = 0 ;
21284 long val2 ;
21285 int ecode2 = 0 ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 char * kwnames[] = {
21289 (char *) "self",(char *) "ts", NULL
21290 };
21291
21292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21294 if (!SWIG_IsOK(res1)) {
21295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21296 }
21297 arg1 = reinterpret_cast< wxEvent * >(argp1);
21298 if (obj1) {
21299 ecode2 = SWIG_AsVal_long(obj1, &val2);
21300 if (!SWIG_IsOK(ecode2)) {
21301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21302 }
21303 arg2 = static_cast< long >(val2);
21304 }
21305 {
21306 PyThreadState* __tstate = wxPyBeginAllowThreads();
21307 (arg1)->SetTimestamp(arg2);
21308 wxPyEndAllowThreads(__tstate);
21309 if (PyErr_Occurred()) SWIG_fail;
21310 }
21311 resultobj = SWIG_Py_Void();
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxEvent *arg1 = (wxEvent *) 0 ;
21321 int result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21331 }
21332 arg1 = reinterpret_cast< wxEvent * >(argp1);
21333 {
21334 PyThreadState* __tstate = wxPyBeginAllowThreads();
21335 result = (int)((wxEvent const *)arg1)->GetId();
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 resultobj = SWIG_From_int(static_cast< int >(result));
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21347 PyObject *resultobj = 0;
21348 wxEvent *arg1 = (wxEvent *) 0 ;
21349 int arg2 ;
21350 void *argp1 = 0 ;
21351 int res1 = 0 ;
21352 int val2 ;
21353 int ecode2 = 0 ;
21354 PyObject * obj0 = 0 ;
21355 PyObject * obj1 = 0 ;
21356 char * kwnames[] = {
21357 (char *) "self",(char *) "Id", NULL
21358 };
21359
21360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21362 if (!SWIG_IsOK(res1)) {
21363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21364 }
21365 arg1 = reinterpret_cast< wxEvent * >(argp1);
21366 ecode2 = SWIG_AsVal_int(obj1, &val2);
21367 if (!SWIG_IsOK(ecode2)) {
21368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21369 }
21370 arg2 = static_cast< int >(val2);
21371 {
21372 PyThreadState* __tstate = wxPyBeginAllowThreads();
21373 (arg1)->SetId(arg2);
21374 wxPyEndAllowThreads(__tstate);
21375 if (PyErr_Occurred()) SWIG_fail;
21376 }
21377 resultobj = SWIG_Py_Void();
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21385 PyObject *resultobj = 0;
21386 wxEvent *arg1 = (wxEvent *) 0 ;
21387 bool result;
21388 void *argp1 = 0 ;
21389 int res1 = 0 ;
21390 PyObject *swig_obj[1] ;
21391
21392 if (!args) SWIG_fail;
21393 swig_obj[0] = args;
21394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21395 if (!SWIG_IsOK(res1)) {
21396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21397 }
21398 arg1 = reinterpret_cast< wxEvent * >(argp1);
21399 {
21400 PyThreadState* __tstate = wxPyBeginAllowThreads();
21401 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21402 wxPyEndAllowThreads(__tstate);
21403 if (PyErr_Occurred()) SWIG_fail;
21404 }
21405 {
21406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21407 }
21408 return resultobj;
21409 fail:
21410 return NULL;
21411 }
21412
21413
21414 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21415 PyObject *resultobj = 0;
21416 wxEvent *arg1 = (wxEvent *) 0 ;
21417 bool arg2 = (bool) true ;
21418 void *argp1 = 0 ;
21419 int res1 = 0 ;
21420 bool val2 ;
21421 int ecode2 = 0 ;
21422 PyObject * obj0 = 0 ;
21423 PyObject * obj1 = 0 ;
21424 char * kwnames[] = {
21425 (char *) "self",(char *) "skip", NULL
21426 };
21427
21428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21430 if (!SWIG_IsOK(res1)) {
21431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21432 }
21433 arg1 = reinterpret_cast< wxEvent * >(argp1);
21434 if (obj1) {
21435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21436 if (!SWIG_IsOK(ecode2)) {
21437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21438 }
21439 arg2 = static_cast< bool >(val2);
21440 }
21441 {
21442 PyThreadState* __tstate = wxPyBeginAllowThreads();
21443 (arg1)->Skip(arg2);
21444 wxPyEndAllowThreads(__tstate);
21445 if (PyErr_Occurred()) SWIG_fail;
21446 }
21447 resultobj = SWIG_Py_Void();
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21455 PyObject *resultobj = 0;
21456 wxEvent *arg1 = (wxEvent *) 0 ;
21457 bool result;
21458 void *argp1 = 0 ;
21459 int res1 = 0 ;
21460 PyObject *swig_obj[1] ;
21461
21462 if (!args) SWIG_fail;
21463 swig_obj[0] = args;
21464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21465 if (!SWIG_IsOK(res1)) {
21466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21467 }
21468 arg1 = reinterpret_cast< wxEvent * >(argp1);
21469 {
21470 PyThreadState* __tstate = wxPyBeginAllowThreads();
21471 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21472 wxPyEndAllowThreads(__tstate);
21473 if (PyErr_Occurred()) SWIG_fail;
21474 }
21475 {
21476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21477 }
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21485 PyObject *resultobj = 0;
21486 wxEvent *arg1 = (wxEvent *) 0 ;
21487 bool result;
21488 void *argp1 = 0 ;
21489 int res1 = 0 ;
21490 PyObject *swig_obj[1] ;
21491
21492 if (!args) SWIG_fail;
21493 swig_obj[0] = args;
21494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21497 }
21498 arg1 = reinterpret_cast< wxEvent * >(argp1);
21499 {
21500 PyThreadState* __tstate = wxPyBeginAllowThreads();
21501 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21502 wxPyEndAllowThreads(__tstate);
21503 if (PyErr_Occurred()) SWIG_fail;
21504 }
21505 {
21506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21507 }
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21515 PyObject *resultobj = 0;
21516 wxEvent *arg1 = (wxEvent *) 0 ;
21517 int result;
21518 void *argp1 = 0 ;
21519 int res1 = 0 ;
21520 PyObject *swig_obj[1] ;
21521
21522 if (!args) SWIG_fail;
21523 swig_obj[0] = args;
21524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21525 if (!SWIG_IsOK(res1)) {
21526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21527 }
21528 arg1 = reinterpret_cast< wxEvent * >(argp1);
21529 {
21530 PyThreadState* __tstate = wxPyBeginAllowThreads();
21531 result = (int)(arg1)->StopPropagation();
21532 wxPyEndAllowThreads(__tstate);
21533 if (PyErr_Occurred()) SWIG_fail;
21534 }
21535 resultobj = SWIG_From_int(static_cast< int >(result));
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21543 PyObject *resultobj = 0;
21544 wxEvent *arg1 = (wxEvent *) 0 ;
21545 int arg2 ;
21546 void *argp1 = 0 ;
21547 int res1 = 0 ;
21548 int val2 ;
21549 int ecode2 = 0 ;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 char * kwnames[] = {
21553 (char *) "self",(char *) "propagationLevel", NULL
21554 };
21555
21556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21558 if (!SWIG_IsOK(res1)) {
21559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21560 }
21561 arg1 = reinterpret_cast< wxEvent * >(argp1);
21562 ecode2 = SWIG_AsVal_int(obj1, &val2);
21563 if (!SWIG_IsOK(ecode2)) {
21564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21565 }
21566 arg2 = static_cast< int >(val2);
21567 {
21568 PyThreadState* __tstate = wxPyBeginAllowThreads();
21569 (arg1)->ResumePropagation(arg2);
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 resultobj = SWIG_Py_Void();
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21581 PyObject *resultobj = 0;
21582 wxEvent *arg1 = (wxEvent *) 0 ;
21583 wxEvent *result = 0 ;
21584 void *argp1 = 0 ;
21585 int res1 = 0 ;
21586 PyObject *swig_obj[1] ;
21587
21588 if (!args) SWIG_fail;
21589 swig_obj[0] = args;
21590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21591 if (!SWIG_IsOK(res1)) {
21592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21593 }
21594 arg1 = reinterpret_cast< wxEvent * >(argp1);
21595 {
21596 PyThreadState* __tstate = wxPyBeginAllowThreads();
21597 result = (wxEvent *)(arg1)->Clone();
21598 wxPyEndAllowThreads(__tstate);
21599 if (PyErr_Occurred()) SWIG_fail;
21600 }
21601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21609 PyObject *obj;
21610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21611 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21612 return SWIG_Py_Void();
21613 }
21614
21615 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21616 PyObject *resultobj = 0;
21617 wxEvent *arg1 = 0 ;
21618 wxPropagationDisabler *result = 0 ;
21619 void *argp1 = 0 ;
21620 int res1 = 0 ;
21621 PyObject * obj0 = 0 ;
21622 char * kwnames[] = {
21623 (char *) "event", NULL
21624 };
21625
21626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21627 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21628 if (!SWIG_IsOK(res1)) {
21629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21630 }
21631 if (!argp1) {
21632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21633 }
21634 arg1 = reinterpret_cast< wxEvent * >(argp1);
21635 {
21636 PyThreadState* __tstate = wxPyBeginAllowThreads();
21637 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21638 wxPyEndAllowThreads(__tstate);
21639 if (PyErr_Occurred()) SWIG_fail;
21640 }
21641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21642 return resultobj;
21643 fail:
21644 return NULL;
21645 }
21646
21647
21648 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21649 PyObject *resultobj = 0;
21650 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21651 void *argp1 = 0 ;
21652 int res1 = 0 ;
21653 PyObject *swig_obj[1] ;
21654
21655 if (!args) SWIG_fail;
21656 swig_obj[0] = args;
21657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21658 if (!SWIG_IsOK(res1)) {
21659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21660 }
21661 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 delete arg1;
21665
21666 wxPyEndAllowThreads(__tstate);
21667 if (PyErr_Occurred()) SWIG_fail;
21668 }
21669 resultobj = SWIG_Py_Void();
21670 return resultobj;
21671 fail:
21672 return NULL;
21673 }
21674
21675
21676 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21677 PyObject *obj;
21678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21679 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21680 return SWIG_Py_Void();
21681 }
21682
21683 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21684 return SWIG_Python_InitShadowInstance(args);
21685 }
21686
21687 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21688 PyObject *resultobj = 0;
21689 wxEvent *arg1 = 0 ;
21690 wxPropagateOnce *result = 0 ;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 PyObject * obj0 = 0 ;
21694 char * kwnames[] = {
21695 (char *) "event", NULL
21696 };
21697
21698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21702 }
21703 if (!argp1) {
21704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21705 }
21706 arg1 = reinterpret_cast< wxEvent * >(argp1);
21707 {
21708 PyThreadState* __tstate = wxPyBeginAllowThreads();
21709 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21710 wxPyEndAllowThreads(__tstate);
21711 if (PyErr_Occurred()) SWIG_fail;
21712 }
21713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21714 return resultobj;
21715 fail:
21716 return NULL;
21717 }
21718
21719
21720 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21721 PyObject *resultobj = 0;
21722 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21732 }
21733 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 delete arg1;
21737
21738 wxPyEndAllowThreads(__tstate);
21739 if (PyErr_Occurred()) SWIG_fail;
21740 }
21741 resultobj = SWIG_Py_Void();
21742 return resultobj;
21743 fail:
21744 return NULL;
21745 }
21746
21747
21748 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 PyObject *obj;
21750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21751 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21752 return SWIG_Py_Void();
21753 }
21754
21755 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 return SWIG_Python_InitShadowInstance(args);
21757 }
21758
21759 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21760 PyObject *resultobj = 0;
21761 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21762 int arg2 = (int) 0 ;
21763 wxCommandEvent *result = 0 ;
21764 int val1 ;
21765 int ecode1 = 0 ;
21766 int val2 ;
21767 int ecode2 = 0 ;
21768 PyObject * obj0 = 0 ;
21769 PyObject * obj1 = 0 ;
21770 char * kwnames[] = {
21771 (char *) "commandType",(char *) "winid", NULL
21772 };
21773
21774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21775 if (obj0) {
21776 ecode1 = SWIG_AsVal_int(obj0, &val1);
21777 if (!SWIG_IsOK(ecode1)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21779 }
21780 arg1 = static_cast< wxEventType >(val1);
21781 }
21782 if (obj1) {
21783 ecode2 = SWIG_AsVal_int(obj1, &val2);
21784 if (!SWIG_IsOK(ecode2)) {
21785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21786 }
21787 arg2 = static_cast< int >(val2);
21788 }
21789 {
21790 PyThreadState* __tstate = wxPyBeginAllowThreads();
21791 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21796 return resultobj;
21797 fail:
21798 return NULL;
21799 }
21800
21801
21802 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21803 PyObject *resultobj = 0;
21804 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21805 int result;
21806 void *argp1 = 0 ;
21807 int res1 = 0 ;
21808 PyObject *swig_obj[1] ;
21809
21810 if (!args) SWIG_fail;
21811 swig_obj[0] = args;
21812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21813 if (!SWIG_IsOK(res1)) {
21814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21815 }
21816 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21817 {
21818 PyThreadState* __tstate = wxPyBeginAllowThreads();
21819 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21820 wxPyEndAllowThreads(__tstate);
21821 if (PyErr_Occurred()) SWIG_fail;
21822 }
21823 resultobj = SWIG_From_int(static_cast< int >(result));
21824 return resultobj;
21825 fail:
21826 return NULL;
21827 }
21828
21829
21830 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj = 0;
21832 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21833 wxString *arg2 = 0 ;
21834 void *argp1 = 0 ;
21835 int res1 = 0 ;
21836 bool temp2 = false ;
21837 PyObject * obj0 = 0 ;
21838 PyObject * obj1 = 0 ;
21839 char * kwnames[] = {
21840 (char *) "self",(char *) "s", NULL
21841 };
21842
21843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21845 if (!SWIG_IsOK(res1)) {
21846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21847 }
21848 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21849 {
21850 arg2 = wxString_in_helper(obj1);
21851 if (arg2 == NULL) SWIG_fail;
21852 temp2 = true;
21853 }
21854 {
21855 PyThreadState* __tstate = wxPyBeginAllowThreads();
21856 (arg1)->SetString((wxString const &)*arg2);
21857 wxPyEndAllowThreads(__tstate);
21858 if (PyErr_Occurred()) SWIG_fail;
21859 }
21860 resultobj = SWIG_Py_Void();
21861 {
21862 if (temp2)
21863 delete arg2;
21864 }
21865 return resultobj;
21866 fail:
21867 {
21868 if (temp2)
21869 delete arg2;
21870 }
21871 return NULL;
21872 }
21873
21874
21875 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21876 PyObject *resultobj = 0;
21877 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21878 wxString result;
21879 void *argp1 = 0 ;
21880 int res1 = 0 ;
21881 PyObject *swig_obj[1] ;
21882
21883 if (!args) SWIG_fail;
21884 swig_obj[0] = args;
21885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21886 if (!SWIG_IsOK(res1)) {
21887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21888 }
21889 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 result = ((wxCommandEvent const *)arg1)->GetString();
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 {
21897 #if wxUSE_UNICODE
21898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21899 #else
21900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21901 #endif
21902 }
21903 return resultobj;
21904 fail:
21905 return NULL;
21906 }
21907
21908
21909 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21910 PyObject *resultobj = 0;
21911 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21912 bool result;
21913 void *argp1 = 0 ;
21914 int res1 = 0 ;
21915 PyObject *swig_obj[1] ;
21916
21917 if (!args) SWIG_fail;
21918 swig_obj[0] = args;
21919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21920 if (!SWIG_IsOK(res1)) {
21921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21922 }
21923 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21924 {
21925 PyThreadState* __tstate = wxPyBeginAllowThreads();
21926 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21927 wxPyEndAllowThreads(__tstate);
21928 if (PyErr_Occurred()) SWIG_fail;
21929 }
21930 {
21931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21932 }
21933 return resultobj;
21934 fail:
21935 return NULL;
21936 }
21937
21938
21939 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21940 PyObject *resultobj = 0;
21941 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21942 bool result;
21943 void *argp1 = 0 ;
21944 int res1 = 0 ;
21945 PyObject *swig_obj[1] ;
21946
21947 if (!args) SWIG_fail;
21948 swig_obj[0] = args;
21949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21950 if (!SWIG_IsOK(res1)) {
21951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21952 }
21953 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21962 }
21963 return resultobj;
21964 fail:
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21970 PyObject *resultobj = 0;
21971 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21972 long arg2 ;
21973 void *argp1 = 0 ;
21974 int res1 = 0 ;
21975 long val2 ;
21976 int ecode2 = 0 ;
21977 PyObject * obj0 = 0 ;
21978 PyObject * obj1 = 0 ;
21979 char * kwnames[] = {
21980 (char *) "self",(char *) "extraLong", NULL
21981 };
21982
21983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21985 if (!SWIG_IsOK(res1)) {
21986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21987 }
21988 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21989 ecode2 = SWIG_AsVal_long(obj1, &val2);
21990 if (!SWIG_IsOK(ecode2)) {
21991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21992 }
21993 arg2 = static_cast< long >(val2);
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 (arg1)->SetExtraLong(arg2);
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 resultobj = SWIG_Py_Void();
22001 return resultobj;
22002 fail:
22003 return NULL;
22004 }
22005
22006
22007 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22008 PyObject *resultobj = 0;
22009 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22010 long result;
22011 void *argp1 = 0 ;
22012 int res1 = 0 ;
22013 PyObject *swig_obj[1] ;
22014
22015 if (!args) SWIG_fail;
22016 swig_obj[0] = args;
22017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22018 if (!SWIG_IsOK(res1)) {
22019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22020 }
22021 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22022 {
22023 PyThreadState* __tstate = wxPyBeginAllowThreads();
22024 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22025 wxPyEndAllowThreads(__tstate);
22026 if (PyErr_Occurred()) SWIG_fail;
22027 }
22028 resultobj = SWIG_From_long(static_cast< long >(result));
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22036 PyObject *resultobj = 0;
22037 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22038 int arg2 ;
22039 void *argp1 = 0 ;
22040 int res1 = 0 ;
22041 int val2 ;
22042 int ecode2 = 0 ;
22043 PyObject * obj0 = 0 ;
22044 PyObject * obj1 = 0 ;
22045 char * kwnames[] = {
22046 (char *) "self",(char *) "i", NULL
22047 };
22048
22049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22051 if (!SWIG_IsOK(res1)) {
22052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22053 }
22054 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22055 ecode2 = SWIG_AsVal_int(obj1, &val2);
22056 if (!SWIG_IsOK(ecode2)) {
22057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22058 }
22059 arg2 = static_cast< int >(val2);
22060 {
22061 PyThreadState* __tstate = wxPyBeginAllowThreads();
22062 (arg1)->SetInt(arg2);
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 resultobj = SWIG_Py_Void();
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22074 PyObject *resultobj = 0;
22075 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22076 int result;
22077 void *argp1 = 0 ;
22078 int res1 = 0 ;
22079 PyObject *swig_obj[1] ;
22080
22081 if (!args) SWIG_fail;
22082 swig_obj[0] = args;
22083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22084 if (!SWIG_IsOK(res1)) {
22085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22086 }
22087 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 resultobj = SWIG_From_int(static_cast< int >(result));
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22102 PyObject *resultobj = 0;
22103 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22104 PyObject *result = 0 ;
22105 void *argp1 = 0 ;
22106 int res1 = 0 ;
22107 PyObject *swig_obj[1] ;
22108
22109 if (!args) SWIG_fail;
22110 swig_obj[0] = args;
22111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22112 if (!SWIG_IsOK(res1)) {
22113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22114 }
22115 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22119 wxPyEndAllowThreads(__tstate);
22120 if (PyErr_Occurred()) SWIG_fail;
22121 }
22122 resultobj = result;
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22130 PyObject *resultobj = 0;
22131 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22132 PyObject *arg2 = (PyObject *) 0 ;
22133 void *argp1 = 0 ;
22134 int res1 = 0 ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char * kwnames[] = {
22138 (char *) "self",(char *) "clientData", NULL
22139 };
22140
22141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22145 }
22146 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22147 arg2 = obj1;
22148 {
22149 PyThreadState* __tstate = wxPyBeginAllowThreads();
22150 wxCommandEvent_SetClientData(arg1,arg2);
22151 wxPyEndAllowThreads(__tstate);
22152 if (PyErr_Occurred()) SWIG_fail;
22153 }
22154 resultobj = SWIG_Py_Void();
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 PyObject *resultobj = 0;
22163 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22164 wxEvent *result = 0 ;
22165 void *argp1 = 0 ;
22166 int res1 = 0 ;
22167 PyObject *swig_obj[1] ;
22168
22169 if (!args) SWIG_fail;
22170 swig_obj[0] = args;
22171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22172 if (!SWIG_IsOK(res1)) {
22173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22174 }
22175 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22176 {
22177 PyThreadState* __tstate = wxPyBeginAllowThreads();
22178 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22179 wxPyEndAllowThreads(__tstate);
22180 if (PyErr_Occurred()) SWIG_fail;
22181 }
22182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 PyObject *obj;
22191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22193 return SWIG_Py_Void();
22194 }
22195
22196 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 return SWIG_Python_InitShadowInstance(args);
22198 }
22199
22200 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22201 PyObject *resultobj = 0;
22202 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22203 int arg2 = (int) 0 ;
22204 wxNotifyEvent *result = 0 ;
22205 int val1 ;
22206 int ecode1 = 0 ;
22207 int val2 ;
22208 int ecode2 = 0 ;
22209 PyObject * obj0 = 0 ;
22210 PyObject * obj1 = 0 ;
22211 char * kwnames[] = {
22212 (char *) "commandType",(char *) "winid", NULL
22213 };
22214
22215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22216 if (obj0) {
22217 ecode1 = SWIG_AsVal_int(obj0, &val1);
22218 if (!SWIG_IsOK(ecode1)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22220 }
22221 arg1 = static_cast< wxEventType >(val1);
22222 }
22223 if (obj1) {
22224 ecode2 = SWIG_AsVal_int(obj1, &val2);
22225 if (!SWIG_IsOK(ecode2)) {
22226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22227 }
22228 arg2 = static_cast< int >(val2);
22229 }
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22244 PyObject *resultobj = 0;
22245 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22246 void *argp1 = 0 ;
22247 int res1 = 0 ;
22248 PyObject *swig_obj[1] ;
22249
22250 if (!args) SWIG_fail;
22251 swig_obj[0] = args;
22252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22253 if (!SWIG_IsOK(res1)) {
22254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22255 }
22256 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22257 {
22258 PyThreadState* __tstate = wxPyBeginAllowThreads();
22259 (arg1)->Veto();
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 resultobj = SWIG_Py_Void();
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22271 PyObject *resultobj = 0;
22272 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22273 void *argp1 = 0 ;
22274 int res1 = 0 ;
22275 PyObject *swig_obj[1] ;
22276
22277 if (!args) SWIG_fail;
22278 swig_obj[0] = args;
22279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22282 }
22283 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 (arg1)->Allow();
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 resultobj = SWIG_Py_Void();
22291 return resultobj;
22292 fail:
22293 return NULL;
22294 }
22295
22296
22297 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22298 PyObject *resultobj = 0;
22299 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22300 bool result;
22301 void *argp1 = 0 ;
22302 int res1 = 0 ;
22303 PyObject *swig_obj[1] ;
22304
22305 if (!args) SWIG_fail;
22306 swig_obj[0] = args;
22307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22308 if (!SWIG_IsOK(res1)) {
22309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22310 }
22311 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22312 {
22313 PyThreadState* __tstate = wxPyBeginAllowThreads();
22314 result = (bool)(arg1)->IsAllowed();
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22328 PyObject *obj;
22329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22330 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22331 return SWIG_Py_Void();
22332 }
22333
22334 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22335 return SWIG_Python_InitShadowInstance(args);
22336 }
22337
22338 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj = 0;
22340 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22341 int arg2 = (int) 0 ;
22342 int arg3 = (int) 0 ;
22343 int arg4 = (int) 0 ;
22344 wxScrollEvent *result = 0 ;
22345 int val1 ;
22346 int ecode1 = 0 ;
22347 int val2 ;
22348 int ecode2 = 0 ;
22349 int val3 ;
22350 int ecode3 = 0 ;
22351 int val4 ;
22352 int ecode4 = 0 ;
22353 PyObject * obj0 = 0 ;
22354 PyObject * obj1 = 0 ;
22355 PyObject * obj2 = 0 ;
22356 PyObject * obj3 = 0 ;
22357 char * kwnames[] = {
22358 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22359 };
22360
22361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22362 if (obj0) {
22363 ecode1 = SWIG_AsVal_int(obj0, &val1);
22364 if (!SWIG_IsOK(ecode1)) {
22365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22366 }
22367 arg1 = static_cast< wxEventType >(val1);
22368 }
22369 if (obj1) {
22370 ecode2 = SWIG_AsVal_int(obj1, &val2);
22371 if (!SWIG_IsOK(ecode2)) {
22372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22373 }
22374 arg2 = static_cast< int >(val2);
22375 }
22376 if (obj2) {
22377 ecode3 = SWIG_AsVal_int(obj2, &val3);
22378 if (!SWIG_IsOK(ecode3)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22380 }
22381 arg3 = static_cast< int >(val3);
22382 }
22383 if (obj3) {
22384 ecode4 = SWIG_AsVal_int(obj3, &val4);
22385 if (!SWIG_IsOK(ecode4)) {
22386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22387 }
22388 arg4 = static_cast< int >(val4);
22389 }
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22406 int result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 PyObject *swig_obj[1] ;
22410
22411 if (!args) SWIG_fail;
22412 swig_obj[0] = args;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22416 }
22417 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_From_int(static_cast< int >(result));
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22432 PyObject *resultobj = 0;
22433 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22434 int result;
22435 void *argp1 = 0 ;
22436 int res1 = 0 ;
22437 PyObject *swig_obj[1] ;
22438
22439 if (!args) SWIG_fail;
22440 swig_obj[0] = args;
22441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22442 if (!SWIG_IsOK(res1)) {
22443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22444 }
22445 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22449 wxPyEndAllowThreads(__tstate);
22450 if (PyErr_Occurred()) SWIG_fail;
22451 }
22452 resultobj = SWIG_From_int(static_cast< int >(result));
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22460 PyObject *resultobj = 0;
22461 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22462 int arg2 ;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 int val2 ;
22466 int ecode2 = 0 ;
22467 PyObject * obj0 = 0 ;
22468 PyObject * obj1 = 0 ;
22469 char * kwnames[] = {
22470 (char *) "self",(char *) "orient", NULL
22471 };
22472
22473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22475 if (!SWIG_IsOK(res1)) {
22476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22477 }
22478 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22479 ecode2 = SWIG_AsVal_int(obj1, &val2);
22480 if (!SWIG_IsOK(ecode2)) {
22481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22482 }
22483 arg2 = static_cast< int >(val2);
22484 {
22485 PyThreadState* __tstate = wxPyBeginAllowThreads();
22486 (arg1)->SetOrientation(arg2);
22487 wxPyEndAllowThreads(__tstate);
22488 if (PyErr_Occurred()) SWIG_fail;
22489 }
22490 resultobj = SWIG_Py_Void();
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22498 PyObject *resultobj = 0;
22499 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22500 int arg2 ;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 int val2 ;
22504 int ecode2 = 0 ;
22505 PyObject * obj0 = 0 ;
22506 PyObject * obj1 = 0 ;
22507 char * kwnames[] = {
22508 (char *) "self",(char *) "pos", NULL
22509 };
22510
22511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22513 if (!SWIG_IsOK(res1)) {
22514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22515 }
22516 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22517 ecode2 = SWIG_AsVal_int(obj1, &val2);
22518 if (!SWIG_IsOK(ecode2)) {
22519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22520 }
22521 arg2 = static_cast< int >(val2);
22522 {
22523 PyThreadState* __tstate = wxPyBeginAllowThreads();
22524 (arg1)->SetPosition(arg2);
22525 wxPyEndAllowThreads(__tstate);
22526 if (PyErr_Occurred()) SWIG_fail;
22527 }
22528 resultobj = SWIG_Py_Void();
22529 return resultobj;
22530 fail:
22531 return NULL;
22532 }
22533
22534
22535 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22536 PyObject *obj;
22537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22538 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22539 return SWIG_Py_Void();
22540 }
22541
22542 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22543 return SWIG_Python_InitShadowInstance(args);
22544 }
22545
22546 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22547 PyObject *resultobj = 0;
22548 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22549 int arg2 = (int) 0 ;
22550 int arg3 = (int) 0 ;
22551 wxScrollWinEvent *result = 0 ;
22552 int val1 ;
22553 int ecode1 = 0 ;
22554 int val2 ;
22555 int ecode2 = 0 ;
22556 int val3 ;
22557 int ecode3 = 0 ;
22558 PyObject * obj0 = 0 ;
22559 PyObject * obj1 = 0 ;
22560 PyObject * obj2 = 0 ;
22561 char * kwnames[] = {
22562 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22563 };
22564
22565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22566 if (obj0) {
22567 ecode1 = SWIG_AsVal_int(obj0, &val1);
22568 if (!SWIG_IsOK(ecode1)) {
22569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22570 }
22571 arg1 = static_cast< wxEventType >(val1);
22572 }
22573 if (obj1) {
22574 ecode2 = SWIG_AsVal_int(obj1, &val2);
22575 if (!SWIG_IsOK(ecode2)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22577 }
22578 arg2 = static_cast< int >(val2);
22579 }
22580 if (obj2) {
22581 ecode3 = SWIG_AsVal_int(obj2, &val3);
22582 if (!SWIG_IsOK(ecode3)) {
22583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22584 }
22585 arg3 = static_cast< int >(val3);
22586 }
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22590 wxPyEndAllowThreads(__tstate);
22591 if (PyErr_Occurred()) SWIG_fail;
22592 }
22593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22594 return resultobj;
22595 fail:
22596 return NULL;
22597 }
22598
22599
22600 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22601 PyObject *resultobj = 0;
22602 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22603 int result;
22604 void *argp1 = 0 ;
22605 int res1 = 0 ;
22606 PyObject *swig_obj[1] ;
22607
22608 if (!args) SWIG_fail;
22609 swig_obj[0] = args;
22610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22611 if (!SWIG_IsOK(res1)) {
22612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22613 }
22614 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22615 {
22616 PyThreadState* __tstate = wxPyBeginAllowThreads();
22617 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 resultobj = SWIG_From_int(static_cast< int >(result));
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22629 PyObject *resultobj = 0;
22630 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22631 int result;
22632 void *argp1 = 0 ;
22633 int res1 = 0 ;
22634 PyObject *swig_obj[1] ;
22635
22636 if (!args) SWIG_fail;
22637 swig_obj[0] = args;
22638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22639 if (!SWIG_IsOK(res1)) {
22640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22641 }
22642 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22643 {
22644 PyThreadState* __tstate = wxPyBeginAllowThreads();
22645 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22646 wxPyEndAllowThreads(__tstate);
22647 if (PyErr_Occurred()) SWIG_fail;
22648 }
22649 resultobj = SWIG_From_int(static_cast< int >(result));
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22657 PyObject *resultobj = 0;
22658 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22659 int arg2 ;
22660 void *argp1 = 0 ;
22661 int res1 = 0 ;
22662 int val2 ;
22663 int ecode2 = 0 ;
22664 PyObject * obj0 = 0 ;
22665 PyObject * obj1 = 0 ;
22666 char * kwnames[] = {
22667 (char *) "self",(char *) "orient", NULL
22668 };
22669
22670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22672 if (!SWIG_IsOK(res1)) {
22673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22674 }
22675 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22676 ecode2 = SWIG_AsVal_int(obj1, &val2);
22677 if (!SWIG_IsOK(ecode2)) {
22678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22679 }
22680 arg2 = static_cast< int >(val2);
22681 {
22682 PyThreadState* __tstate = wxPyBeginAllowThreads();
22683 (arg1)->SetOrientation(arg2);
22684 wxPyEndAllowThreads(__tstate);
22685 if (PyErr_Occurred()) SWIG_fail;
22686 }
22687 resultobj = SWIG_Py_Void();
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22695 PyObject *resultobj = 0;
22696 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22697 int arg2 ;
22698 void *argp1 = 0 ;
22699 int res1 = 0 ;
22700 int val2 ;
22701 int ecode2 = 0 ;
22702 PyObject * obj0 = 0 ;
22703 PyObject * obj1 = 0 ;
22704 char * kwnames[] = {
22705 (char *) "self",(char *) "pos", NULL
22706 };
22707
22708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22710 if (!SWIG_IsOK(res1)) {
22711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22712 }
22713 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22714 ecode2 = SWIG_AsVal_int(obj1, &val2);
22715 if (!SWIG_IsOK(ecode2)) {
22716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22717 }
22718 arg2 = static_cast< int >(val2);
22719 {
22720 PyThreadState* __tstate = wxPyBeginAllowThreads();
22721 (arg1)->SetPosition(arg2);
22722 wxPyEndAllowThreads(__tstate);
22723 if (PyErr_Occurred()) SWIG_fail;
22724 }
22725 resultobj = SWIG_Py_Void();
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *obj;
22734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22735 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22736 return SWIG_Py_Void();
22737 }
22738
22739 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 return SWIG_Python_InitShadowInstance(args);
22741 }
22742
22743 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj = 0;
22745 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22746 wxMouseEvent *result = 0 ;
22747 int val1 ;
22748 int ecode1 = 0 ;
22749 PyObject * obj0 = 0 ;
22750 char * kwnames[] = {
22751 (char *) "mouseType", NULL
22752 };
22753
22754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22755 if (obj0) {
22756 ecode1 = SWIG_AsVal_int(obj0, &val1);
22757 if (!SWIG_IsOK(ecode1)) {
22758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22759 }
22760 arg1 = static_cast< wxEventType >(val1);
22761 }
22762 {
22763 PyThreadState* __tstate = wxPyBeginAllowThreads();
22764 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22765 wxPyEndAllowThreads(__tstate);
22766 if (PyErr_Occurred()) SWIG_fail;
22767 }
22768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22769 return resultobj;
22770 fail:
22771 return NULL;
22772 }
22773
22774
22775 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776 PyObject *resultobj = 0;
22777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22778 bool result;
22779 void *argp1 = 0 ;
22780 int res1 = 0 ;
22781 PyObject *swig_obj[1] ;
22782
22783 if (!args) SWIG_fail;
22784 swig_obj[0] = args;
22785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22786 if (!SWIG_IsOK(res1)) {
22787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22788 }
22789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22790 {
22791 PyThreadState* __tstate = wxPyBeginAllowThreads();
22792 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22793 wxPyEndAllowThreads(__tstate);
22794 if (PyErr_Occurred()) SWIG_fail;
22795 }
22796 {
22797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22798 }
22799 return resultobj;
22800 fail:
22801 return NULL;
22802 }
22803
22804
22805 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22806 PyObject *resultobj = 0;
22807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22808 int arg2 = (int) wxMOUSE_BTN_ANY ;
22809 bool result;
22810 void *argp1 = 0 ;
22811 int res1 = 0 ;
22812 int val2 ;
22813 int ecode2 = 0 ;
22814 PyObject * obj0 = 0 ;
22815 PyObject * obj1 = 0 ;
22816 char * kwnames[] = {
22817 (char *) "self",(char *) "but", NULL
22818 };
22819
22820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22822 if (!SWIG_IsOK(res1)) {
22823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22824 }
22825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22826 if (obj1) {
22827 ecode2 = SWIG_AsVal_int(obj1, &val2);
22828 if (!SWIG_IsOK(ecode2)) {
22829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22830 }
22831 arg2 = static_cast< int >(val2);
22832 }
22833 {
22834 PyThreadState* __tstate = wxPyBeginAllowThreads();
22835 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 {
22840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22841 }
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj = 0;
22850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22851 int arg2 = (int) wxMOUSE_BTN_ANY ;
22852 bool result;
22853 void *argp1 = 0 ;
22854 int res1 = 0 ;
22855 int val2 ;
22856 int ecode2 = 0 ;
22857 PyObject * obj0 = 0 ;
22858 PyObject * obj1 = 0 ;
22859 char * kwnames[] = {
22860 (char *) "self",(char *) "but", NULL
22861 };
22862
22863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22867 }
22868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22869 if (obj1) {
22870 ecode2 = SWIG_AsVal_int(obj1, &val2);
22871 if (!SWIG_IsOK(ecode2)) {
22872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22873 }
22874 arg2 = static_cast< int >(val2);
22875 }
22876 {
22877 PyThreadState* __tstate = wxPyBeginAllowThreads();
22878 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22879 wxPyEndAllowThreads(__tstate);
22880 if (PyErr_Occurred()) SWIG_fail;
22881 }
22882 {
22883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22884 }
22885 return resultobj;
22886 fail:
22887 return NULL;
22888 }
22889
22890
22891 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22892 PyObject *resultobj = 0;
22893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22894 int arg2 = (int) wxMOUSE_BTN_ANY ;
22895 bool result;
22896 void *argp1 = 0 ;
22897 int res1 = 0 ;
22898 int val2 ;
22899 int ecode2 = 0 ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char * kwnames[] = {
22903 (char *) "self",(char *) "but", NULL
22904 };
22905
22906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22910 }
22911 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22912 if (obj1) {
22913 ecode2 = SWIG_AsVal_int(obj1, &val2);
22914 if (!SWIG_IsOK(ecode2)) {
22915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22916 }
22917 arg2 = static_cast< int >(val2);
22918 }
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22922 wxPyEndAllowThreads(__tstate);
22923 if (PyErr_Occurred()) SWIG_fail;
22924 }
22925 {
22926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22927 }
22928 return resultobj;
22929 fail:
22930 return NULL;
22931 }
22932
22933
22934 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22935 PyObject *resultobj = 0;
22936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22937 int arg2 ;
22938 bool result;
22939 void *argp1 = 0 ;
22940 int res1 = 0 ;
22941 int val2 ;
22942 int ecode2 = 0 ;
22943 PyObject * obj0 = 0 ;
22944 PyObject * obj1 = 0 ;
22945 char * kwnames[] = {
22946 (char *) "self",(char *) "button", NULL
22947 };
22948
22949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22951 if (!SWIG_IsOK(res1)) {
22952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22953 }
22954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22955 ecode2 = SWIG_AsVal_int(obj1, &val2);
22956 if (!SWIG_IsOK(ecode2)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22958 }
22959 arg2 = static_cast< int >(val2);
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 {
22967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22968 }
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22976 PyObject *resultobj = 0;
22977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22978 int arg2 ;
22979 bool result;
22980 void *argp1 = 0 ;
22981 int res1 = 0 ;
22982 int val2 ;
22983 int ecode2 = 0 ;
22984 PyObject * obj0 = 0 ;
22985 PyObject * obj1 = 0 ;
22986 char * kwnames[] = {
22987 (char *) "self",(char *) "but", NULL
22988 };
22989
22990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22992 if (!SWIG_IsOK(res1)) {
22993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22994 }
22995 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22996 ecode2 = SWIG_AsVal_int(obj1, &val2);
22997 if (!SWIG_IsOK(ecode2)) {
22998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22999 }
23000 arg2 = static_cast< int >(val2);
23001 {
23002 PyThreadState* __tstate = wxPyBeginAllowThreads();
23003 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 {
23008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23009 }
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23019 int result;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 PyObject *swig_obj[1] ;
23023
23024 if (!args) SWIG_fail;
23025 swig_obj[0] = args;
23026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23027 if (!SWIG_IsOK(res1)) {
23028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23029 }
23030 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 resultobj = SWIG_From_int(static_cast< int >(result));
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23045 PyObject *resultobj = 0;
23046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23047 bool result;
23048 void *argp1 = 0 ;
23049 int res1 = 0 ;
23050 PyObject *swig_obj[1] ;
23051
23052 if (!args) SWIG_fail;
23053 swig_obj[0] = args;
23054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23055 if (!SWIG_IsOK(res1)) {
23056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23057 }
23058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23062 wxPyEndAllowThreads(__tstate);
23063 if (PyErr_Occurred()) SWIG_fail;
23064 }
23065 {
23066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23067 }
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23075 PyObject *resultobj = 0;
23076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23077 bool result;
23078 void *argp1 = 0 ;
23079 int res1 = 0 ;
23080 PyObject *swig_obj[1] ;
23081
23082 if (!args) SWIG_fail;
23083 swig_obj[0] = args;
23084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23085 if (!SWIG_IsOK(res1)) {
23086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23087 }
23088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23089 {
23090 PyThreadState* __tstate = wxPyBeginAllowThreads();
23091 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23092 wxPyEndAllowThreads(__tstate);
23093 if (PyErr_Occurred()) SWIG_fail;
23094 }
23095 {
23096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23097 }
23098 return resultobj;
23099 fail:
23100 return NULL;
23101 }
23102
23103
23104 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23105 PyObject *resultobj = 0;
23106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23107 bool result;
23108 void *argp1 = 0 ;
23109 int res1 = 0 ;
23110 PyObject *swig_obj[1] ;
23111
23112 if (!args) SWIG_fail;
23113 swig_obj[0] = args;
23114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23115 if (!SWIG_IsOK(res1)) {
23116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23117 }
23118 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23119 {
23120 PyThreadState* __tstate = wxPyBeginAllowThreads();
23121 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 {
23126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23127 }
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23135 PyObject *resultobj = 0;
23136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23137 bool result;
23138 void *argp1 = 0 ;
23139 int res1 = 0 ;
23140 PyObject *swig_obj[1] ;
23141
23142 if (!args) SWIG_fail;
23143 swig_obj[0] = args;
23144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23145 if (!SWIG_IsOK(res1)) {
23146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23147 }
23148 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23149 {
23150 PyThreadState* __tstate = wxPyBeginAllowThreads();
23151 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 {
23156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23157 }
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23165 PyObject *resultobj = 0;
23166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23167 bool result;
23168 void *argp1 = 0 ;
23169 int res1 = 0 ;
23170 PyObject *swig_obj[1] ;
23171
23172 if (!args) SWIG_fail;
23173 swig_obj[0] = args;
23174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23175 if (!SWIG_IsOK(res1)) {
23176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23177 }
23178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23179 {
23180 PyThreadState* __tstate = wxPyBeginAllowThreads();
23181 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 {
23186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23187 }
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23195 PyObject *resultobj = 0;
23196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23197 bool result;
23198 void *argp1 = 0 ;
23199 int res1 = 0 ;
23200 PyObject *swig_obj[1] ;
23201
23202 if (!args) SWIG_fail;
23203 swig_obj[0] = args;
23204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23205 if (!SWIG_IsOK(res1)) {
23206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23207 }
23208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 {
23216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23217 }
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23225 PyObject *resultobj = 0;
23226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23227 bool result;
23228 void *argp1 = 0 ;
23229 int res1 = 0 ;
23230 PyObject *swig_obj[1] ;
23231
23232 if (!args) SWIG_fail;
23233 swig_obj[0] = args;
23234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23235 if (!SWIG_IsOK(res1)) {
23236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23237 }
23238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23239 {
23240 PyThreadState* __tstate = wxPyBeginAllowThreads();
23241 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23255 PyObject *resultobj = 0;
23256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23257 bool result;
23258 void *argp1 = 0 ;
23259 int res1 = 0 ;
23260 PyObject *swig_obj[1] ;
23261
23262 if (!args) SWIG_fail;
23263 swig_obj[0] = args;
23264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23265 if (!SWIG_IsOK(res1)) {
23266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23267 }
23268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23272 wxPyEndAllowThreads(__tstate);
23273 if (PyErr_Occurred()) SWIG_fail;
23274 }
23275 {
23276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23277 }
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23285 PyObject *resultobj = 0;
23286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23287 bool result;
23288 void *argp1 = 0 ;
23289 int res1 = 0 ;
23290 PyObject *swig_obj[1] ;
23291
23292 if (!args) SWIG_fail;
23293 swig_obj[0] = args;
23294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23297 }
23298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23315 PyObject *resultobj = 0;
23316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23317 bool result;
23318 void *argp1 = 0 ;
23319 int res1 = 0 ;
23320 PyObject *swig_obj[1] ;
23321
23322 if (!args) SWIG_fail;
23323 swig_obj[0] = args;
23324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23325 if (!SWIG_IsOK(res1)) {
23326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23327 }
23328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 {
23336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23337 }
23338 return resultobj;
23339 fail:
23340 return NULL;
23341 }
23342
23343
23344 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23345 PyObject *resultobj = 0;
23346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23347 bool result;
23348 void *argp1 = 0 ;
23349 int res1 = 0 ;
23350 PyObject *swig_obj[1] ;
23351
23352 if (!args) SWIG_fail;
23353 swig_obj[0] = args;
23354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23355 if (!SWIG_IsOK(res1)) {
23356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23357 }
23358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23362 wxPyEndAllowThreads(__tstate);
23363 if (PyErr_Occurred()) SWIG_fail;
23364 }
23365 {
23366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23367 }
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 PyObject *resultobj = 0;
23376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23377 bool result;
23378 void *argp1 = 0 ;
23379 int res1 = 0 ;
23380 PyObject *swig_obj[1] ;
23381
23382 if (!args) SWIG_fail;
23383 swig_obj[0] = args;
23384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23385 if (!SWIG_IsOK(res1)) {
23386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23387 }
23388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 {
23396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23397 }
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23405 PyObject *resultobj = 0;
23406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23407 bool result;
23408 void *argp1 = 0 ;
23409 int res1 = 0 ;
23410 PyObject *swig_obj[1] ;
23411
23412 if (!args) SWIG_fail;
23413 swig_obj[0] = args;
23414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23415 if (!SWIG_IsOK(res1)) {
23416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23417 }
23418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 {
23426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23427 }
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23435 PyObject *resultobj = 0;
23436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23437 bool result;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 PyObject *swig_obj[1] ;
23441
23442 if (!args) SWIG_fail;
23443 swig_obj[0] = args;
23444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23445 if (!SWIG_IsOK(res1)) {
23446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23447 }
23448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23452 wxPyEndAllowThreads(__tstate);
23453 if (PyErr_Occurred()) SWIG_fail;
23454 }
23455 {
23456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23457 }
23458 return resultobj;
23459 fail:
23460 return NULL;
23461 }
23462
23463
23464 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23465 PyObject *resultobj = 0;
23466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23467 bool result;
23468 void *argp1 = 0 ;
23469 int res1 = 0 ;
23470 PyObject *swig_obj[1] ;
23471
23472 if (!args) SWIG_fail;
23473 swig_obj[0] = args;
23474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23475 if (!SWIG_IsOK(res1)) {
23476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23477 }
23478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23479 {
23480 PyThreadState* __tstate = wxPyBeginAllowThreads();
23481 result = (bool)(arg1)->LeftIsDown();
23482 wxPyEndAllowThreads(__tstate);
23483 if (PyErr_Occurred()) SWIG_fail;
23484 }
23485 {
23486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23487 }
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *resultobj = 0;
23496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23497 bool result;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 PyObject *swig_obj[1] ;
23501
23502 if (!args) SWIG_fail;
23503 swig_obj[0] = args;
23504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23505 if (!SWIG_IsOK(res1)) {
23506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23507 }
23508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = (bool)(arg1)->MiddleIsDown();
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23517 }
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 PyObject *resultobj = 0;
23526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23527 bool result;
23528 void *argp1 = 0 ;
23529 int res1 = 0 ;
23530 PyObject *swig_obj[1] ;
23531
23532 if (!args) SWIG_fail;
23533 swig_obj[0] = args;
23534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23535 if (!SWIG_IsOK(res1)) {
23536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23537 }
23538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23539 {
23540 PyThreadState* __tstate = wxPyBeginAllowThreads();
23541 result = (bool)(arg1)->RightIsDown();
23542 wxPyEndAllowThreads(__tstate);
23543 if (PyErr_Occurred()) SWIG_fail;
23544 }
23545 {
23546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23547 }
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23555 PyObject *resultobj = 0;
23556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23557 bool result;
23558 void *argp1 = 0 ;
23559 int res1 = 0 ;
23560 PyObject *swig_obj[1] ;
23561
23562 if (!args) SWIG_fail;
23563 swig_obj[0] = args;
23564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23565 if (!SWIG_IsOK(res1)) {
23566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23567 }
23568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23569 {
23570 PyThreadState* __tstate = wxPyBeginAllowThreads();
23571 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23572 wxPyEndAllowThreads(__tstate);
23573 if (PyErr_Occurred()) SWIG_fail;
23574 }
23575 {
23576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23577 }
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23585 PyObject *resultobj = 0;
23586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23587 bool result;
23588 void *argp1 = 0 ;
23589 int res1 = 0 ;
23590 PyObject *swig_obj[1] ;
23591
23592 if (!args) SWIG_fail;
23593 swig_obj[0] = args;
23594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23595 if (!SWIG_IsOK(res1)) {
23596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23597 }
23598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23602 wxPyEndAllowThreads(__tstate);
23603 if (PyErr_Occurred()) SWIG_fail;
23604 }
23605 {
23606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23607 }
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23615 PyObject *resultobj = 0;
23616 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23617 bool result;
23618 void *argp1 = 0 ;
23619 int res1 = 0 ;
23620 PyObject *swig_obj[1] ;
23621
23622 if (!args) SWIG_fail;
23623 swig_obj[0] = args;
23624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23625 if (!SWIG_IsOK(res1)) {
23626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23627 }
23628 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 {
23636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23637 }
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23645 PyObject *resultobj = 0;
23646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23647 bool result;
23648 void *argp1 = 0 ;
23649 int res1 = 0 ;
23650 PyObject *swig_obj[1] ;
23651
23652 if (!args) SWIG_fail;
23653 swig_obj[0] = args;
23654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23655 if (!SWIG_IsOK(res1)) {
23656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23657 }
23658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23662 wxPyEndAllowThreads(__tstate);
23663 if (PyErr_Occurred()) SWIG_fail;
23664 }
23665 {
23666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23667 }
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23675 PyObject *resultobj = 0;
23676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23677 wxPoint result;
23678 void *argp1 = 0 ;
23679 int res1 = 0 ;
23680 PyObject *swig_obj[1] ;
23681
23682 if (!args) SWIG_fail;
23683 swig_obj[0] = args;
23684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23685 if (!SWIG_IsOK(res1)) {
23686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23687 }
23688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (arg1)->GetPosition();
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23696 return resultobj;
23697 fail:
23698 return NULL;
23699 }
23700
23701
23702 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23703 PyObject *resultobj = 0;
23704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23705 long *arg2 = (long *) 0 ;
23706 long *arg3 = (long *) 0 ;
23707 void *argp1 = 0 ;
23708 int res1 = 0 ;
23709 long temp2 ;
23710 int res2 = SWIG_TMPOBJ ;
23711 long temp3 ;
23712 int res3 = SWIG_TMPOBJ ;
23713 PyObject *swig_obj[1] ;
23714
23715 arg2 = &temp2;
23716 arg3 = &temp3;
23717 if (!args) SWIG_fail;
23718 swig_obj[0] = args;
23719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23720 if (!SWIG_IsOK(res1)) {
23721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23722 }
23723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 (arg1)->GetPosition(arg2,arg3);
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_Py_Void();
23731 if (SWIG_IsTmpObj(res2)) {
23732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23733 } else {
23734 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23736 }
23737 if (SWIG_IsTmpObj(res3)) {
23738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23739 } else {
23740 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23742 }
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23750 PyObject *resultobj = 0;
23751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23752 wxDC *arg2 = 0 ;
23753 wxPoint result;
23754 void *argp1 = 0 ;
23755 int res1 = 0 ;
23756 void *argp2 = 0 ;
23757 int res2 = 0 ;
23758 PyObject * obj0 = 0 ;
23759 PyObject * obj1 = 0 ;
23760 char * kwnames[] = {
23761 (char *) "self",(char *) "dc", NULL
23762 };
23763
23764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23766 if (!SWIG_IsOK(res1)) {
23767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23768 }
23769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23771 if (!SWIG_IsOK(res2)) {
23772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23773 }
23774 if (!argp2) {
23775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23776 }
23777 arg2 = reinterpret_cast< wxDC * >(argp2);
23778 {
23779 PyThreadState* __tstate = wxPyBeginAllowThreads();
23780 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792 PyObject *resultobj = 0;
23793 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23794 int result;
23795 void *argp1 = 0 ;
23796 int res1 = 0 ;
23797 PyObject *swig_obj[1] ;
23798
23799 if (!args) SWIG_fail;
23800 swig_obj[0] = args;
23801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23802 if (!SWIG_IsOK(res1)) {
23803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23804 }
23805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23806 {
23807 PyThreadState* __tstate = wxPyBeginAllowThreads();
23808 result = (int)((wxMouseEvent const *)arg1)->GetX();
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 resultobj = SWIG_From_int(static_cast< int >(result));
23813 return resultobj;
23814 fail:
23815 return NULL;
23816 }
23817
23818
23819 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23820 PyObject *resultobj = 0;
23821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23822 int result;
23823 void *argp1 = 0 ;
23824 int res1 = 0 ;
23825 PyObject *swig_obj[1] ;
23826
23827 if (!args) SWIG_fail;
23828 swig_obj[0] = args;
23829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23830 if (!SWIG_IsOK(res1)) {
23831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23832 }
23833 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23834 {
23835 PyThreadState* __tstate = wxPyBeginAllowThreads();
23836 result = (int)((wxMouseEvent const *)arg1)->GetY();
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 resultobj = SWIG_From_int(static_cast< int >(result));
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23848 PyObject *resultobj = 0;
23849 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23850 int result;
23851 void *argp1 = 0 ;
23852 int res1 = 0 ;
23853 PyObject *swig_obj[1] ;
23854
23855 if (!args) SWIG_fail;
23856 swig_obj[0] = args;
23857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23858 if (!SWIG_IsOK(res1)) {
23859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23860 }
23861 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23862 {
23863 PyThreadState* __tstate = wxPyBeginAllowThreads();
23864 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23865 wxPyEndAllowThreads(__tstate);
23866 if (PyErr_Occurred()) SWIG_fail;
23867 }
23868 resultobj = SWIG_From_int(static_cast< int >(result));
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 PyObject *resultobj = 0;
23877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23878 int result;
23879 void *argp1 = 0 ;
23880 int res1 = 0 ;
23881 PyObject *swig_obj[1] ;
23882
23883 if (!args) SWIG_fail;
23884 swig_obj[0] = args;
23885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23886 if (!SWIG_IsOK(res1)) {
23887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23888 }
23889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23890 {
23891 PyThreadState* __tstate = wxPyBeginAllowThreads();
23892 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23893 wxPyEndAllowThreads(__tstate);
23894 if (PyErr_Occurred()) SWIG_fail;
23895 }
23896 resultobj = SWIG_From_int(static_cast< int >(result));
23897 return resultobj;
23898 fail:
23899 return NULL;
23900 }
23901
23902
23903 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23904 PyObject *resultobj = 0;
23905 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23906 int result;
23907 void *argp1 = 0 ;
23908 int res1 = 0 ;
23909 PyObject *swig_obj[1] ;
23910
23911 if (!args) SWIG_fail;
23912 swig_obj[0] = args;
23913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23914 if (!SWIG_IsOK(res1)) {
23915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23916 }
23917 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 resultobj = SWIG_From_int(static_cast< int >(result));
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 PyObject *resultobj = 0;
23933 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23934 bool result;
23935 void *argp1 = 0 ;
23936 int res1 = 0 ;
23937 PyObject *swig_obj[1] ;
23938
23939 if (!args) SWIG_fail;
23940 swig_obj[0] = args;
23941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23942 if (!SWIG_IsOK(res1)) {
23943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23944 }
23945 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 {
23953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23954 }
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23962 PyObject *resultobj = 0;
23963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23964 int arg2 ;
23965 void *argp1 = 0 ;
23966 int res1 = 0 ;
23967 int val2 ;
23968 int ecode2 = 0 ;
23969 PyObject *swig_obj[2] ;
23970
23971 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23975 }
23976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23977 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23978 if (!SWIG_IsOK(ecode2)) {
23979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23980 }
23981 arg2 = static_cast< int >(val2);
23982 if (arg1) (arg1)->m_x = arg2;
23983
23984 resultobj = SWIG_Py_Void();
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23994 int result;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 PyObject *swig_obj[1] ;
23998
23999 if (!args) SWIG_fail;
24000 swig_obj[0] = args;
24001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24002 if (!SWIG_IsOK(res1)) {
24003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24004 }
24005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24006 result = (int) ((arg1)->m_x);
24007 resultobj = SWIG_From_int(static_cast< int >(result));
24008 return resultobj;
24009 fail:
24010 return NULL;
24011 }
24012
24013
24014 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24015 PyObject *resultobj = 0;
24016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24017 int arg2 ;
24018 void *argp1 = 0 ;
24019 int res1 = 0 ;
24020 int val2 ;
24021 int ecode2 = 0 ;
24022 PyObject *swig_obj[2] ;
24023
24024 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24026 if (!SWIG_IsOK(res1)) {
24027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24028 }
24029 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24030 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24031 if (!SWIG_IsOK(ecode2)) {
24032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24033 }
24034 arg2 = static_cast< int >(val2);
24035 if (arg1) (arg1)->m_y = arg2;
24036
24037 resultobj = SWIG_Py_Void();
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24045 PyObject *resultobj = 0;
24046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24047 int result;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 PyObject *swig_obj[1] ;
24051
24052 if (!args) SWIG_fail;
24053 swig_obj[0] = args;
24054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24055 if (!SWIG_IsOK(res1)) {
24056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24057 }
24058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24059 result = (int) ((arg1)->m_y);
24060 resultobj = SWIG_From_int(static_cast< int >(result));
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24068 PyObject *resultobj = 0;
24069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24070 bool arg2 ;
24071 void *argp1 = 0 ;
24072 int res1 = 0 ;
24073 bool val2 ;
24074 int ecode2 = 0 ;
24075 PyObject *swig_obj[2] ;
24076
24077 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24079 if (!SWIG_IsOK(res1)) {
24080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24081 }
24082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24083 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24084 if (!SWIG_IsOK(ecode2)) {
24085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24086 }
24087 arg2 = static_cast< bool >(val2);
24088 if (arg1) (arg1)->m_leftDown = arg2;
24089
24090 resultobj = SWIG_Py_Void();
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24098 PyObject *resultobj = 0;
24099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24100 bool result;
24101 void *argp1 = 0 ;
24102 int res1 = 0 ;
24103 PyObject *swig_obj[1] ;
24104
24105 if (!args) SWIG_fail;
24106 swig_obj[0] = args;
24107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24108 if (!SWIG_IsOK(res1)) {
24109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24110 }
24111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24112 result = (bool) ((arg1)->m_leftDown);
24113 {
24114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24115 }
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24123 PyObject *resultobj = 0;
24124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24125 bool arg2 ;
24126 void *argp1 = 0 ;
24127 int res1 = 0 ;
24128 bool val2 ;
24129 int ecode2 = 0 ;
24130 PyObject *swig_obj[2] ;
24131
24132 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24134 if (!SWIG_IsOK(res1)) {
24135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24136 }
24137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24138 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24139 if (!SWIG_IsOK(ecode2)) {
24140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24141 }
24142 arg2 = static_cast< bool >(val2);
24143 if (arg1) (arg1)->m_middleDown = arg2;
24144
24145 resultobj = SWIG_Py_Void();
24146 return resultobj;
24147 fail:
24148 return NULL;
24149 }
24150
24151
24152 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24153 PyObject *resultobj = 0;
24154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24155 bool result;
24156 void *argp1 = 0 ;
24157 int res1 = 0 ;
24158 PyObject *swig_obj[1] ;
24159
24160 if (!args) SWIG_fail;
24161 swig_obj[0] = args;
24162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24163 if (!SWIG_IsOK(res1)) {
24164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24165 }
24166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24167 result = (bool) ((arg1)->m_middleDown);
24168 {
24169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24170 }
24171 return resultobj;
24172 fail:
24173 return NULL;
24174 }
24175
24176
24177 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24178 PyObject *resultobj = 0;
24179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24180 bool arg2 ;
24181 void *argp1 = 0 ;
24182 int res1 = 0 ;
24183 bool val2 ;
24184 int ecode2 = 0 ;
24185 PyObject *swig_obj[2] ;
24186
24187 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24189 if (!SWIG_IsOK(res1)) {
24190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24191 }
24192 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24193 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24194 if (!SWIG_IsOK(ecode2)) {
24195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24196 }
24197 arg2 = static_cast< bool >(val2);
24198 if (arg1) (arg1)->m_rightDown = arg2;
24199
24200 resultobj = SWIG_Py_Void();
24201 return resultobj;
24202 fail:
24203 return NULL;
24204 }
24205
24206
24207 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24208 PyObject *resultobj = 0;
24209 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24210 bool result;
24211 void *argp1 = 0 ;
24212 int res1 = 0 ;
24213 PyObject *swig_obj[1] ;
24214
24215 if (!args) SWIG_fail;
24216 swig_obj[0] = args;
24217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24218 if (!SWIG_IsOK(res1)) {
24219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24220 }
24221 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24222 result = (bool) ((arg1)->m_rightDown);
24223 {
24224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24225 }
24226 return resultobj;
24227 fail:
24228 return NULL;
24229 }
24230
24231
24232 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24233 PyObject *resultobj = 0;
24234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24235 bool arg2 ;
24236 void *argp1 = 0 ;
24237 int res1 = 0 ;
24238 bool val2 ;
24239 int ecode2 = 0 ;
24240 PyObject *swig_obj[2] ;
24241
24242 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24244 if (!SWIG_IsOK(res1)) {
24245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24246 }
24247 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24248 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24249 if (!SWIG_IsOK(ecode2)) {
24250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24251 }
24252 arg2 = static_cast< bool >(val2);
24253 if (arg1) (arg1)->m_controlDown = arg2;
24254
24255 resultobj = SWIG_Py_Void();
24256 return resultobj;
24257 fail:
24258 return NULL;
24259 }
24260
24261
24262 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24263 PyObject *resultobj = 0;
24264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24265 bool result;
24266 void *argp1 = 0 ;
24267 int res1 = 0 ;
24268 PyObject *swig_obj[1] ;
24269
24270 if (!args) SWIG_fail;
24271 swig_obj[0] = args;
24272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24273 if (!SWIG_IsOK(res1)) {
24274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24275 }
24276 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24277 result = (bool) ((arg1)->m_controlDown);
24278 {
24279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24280 }
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24288 PyObject *resultobj = 0;
24289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24290 bool arg2 ;
24291 void *argp1 = 0 ;
24292 int res1 = 0 ;
24293 bool val2 ;
24294 int ecode2 = 0 ;
24295 PyObject *swig_obj[2] ;
24296
24297 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24299 if (!SWIG_IsOK(res1)) {
24300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24301 }
24302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24303 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24304 if (!SWIG_IsOK(ecode2)) {
24305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24306 }
24307 arg2 = static_cast< bool >(val2);
24308 if (arg1) (arg1)->m_shiftDown = arg2;
24309
24310 resultobj = SWIG_Py_Void();
24311 return resultobj;
24312 fail:
24313 return NULL;
24314 }
24315
24316
24317 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24318 PyObject *resultobj = 0;
24319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24320 bool result;
24321 void *argp1 = 0 ;
24322 int res1 = 0 ;
24323 PyObject *swig_obj[1] ;
24324
24325 if (!args) SWIG_fail;
24326 swig_obj[0] = args;
24327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24328 if (!SWIG_IsOK(res1)) {
24329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24330 }
24331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24332 result = (bool) ((arg1)->m_shiftDown);
24333 {
24334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24335 }
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24343 PyObject *resultobj = 0;
24344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24345 bool arg2 ;
24346 void *argp1 = 0 ;
24347 int res1 = 0 ;
24348 bool val2 ;
24349 int ecode2 = 0 ;
24350 PyObject *swig_obj[2] ;
24351
24352 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24354 if (!SWIG_IsOK(res1)) {
24355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24356 }
24357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24358 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24359 if (!SWIG_IsOK(ecode2)) {
24360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24361 }
24362 arg2 = static_cast< bool >(val2);
24363 if (arg1) (arg1)->m_altDown = arg2;
24364
24365 resultobj = SWIG_Py_Void();
24366 return resultobj;
24367 fail:
24368 return NULL;
24369 }
24370
24371
24372 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24373 PyObject *resultobj = 0;
24374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24375 bool result;
24376 void *argp1 = 0 ;
24377 int res1 = 0 ;
24378 PyObject *swig_obj[1] ;
24379
24380 if (!args) SWIG_fail;
24381 swig_obj[0] = args;
24382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24383 if (!SWIG_IsOK(res1)) {
24384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24385 }
24386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24387 result = (bool) ((arg1)->m_altDown);
24388 {
24389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24390 }
24391 return resultobj;
24392 fail:
24393 return NULL;
24394 }
24395
24396
24397 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24398 PyObject *resultobj = 0;
24399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24400 bool arg2 ;
24401 void *argp1 = 0 ;
24402 int res1 = 0 ;
24403 bool val2 ;
24404 int ecode2 = 0 ;
24405 PyObject *swig_obj[2] ;
24406
24407 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24409 if (!SWIG_IsOK(res1)) {
24410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24411 }
24412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24413 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24414 if (!SWIG_IsOK(ecode2)) {
24415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24416 }
24417 arg2 = static_cast< bool >(val2);
24418 if (arg1) (arg1)->m_metaDown = arg2;
24419
24420 resultobj = SWIG_Py_Void();
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24428 PyObject *resultobj = 0;
24429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24430 bool result;
24431 void *argp1 = 0 ;
24432 int res1 = 0 ;
24433 PyObject *swig_obj[1] ;
24434
24435 if (!args) SWIG_fail;
24436 swig_obj[0] = args;
24437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24438 if (!SWIG_IsOK(res1)) {
24439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24440 }
24441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24442 result = (bool) ((arg1)->m_metaDown);
24443 {
24444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24445 }
24446 return resultobj;
24447 fail:
24448 return NULL;
24449 }
24450
24451
24452 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24453 PyObject *resultobj = 0;
24454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24455 int arg2 ;
24456 void *argp1 = 0 ;
24457 int res1 = 0 ;
24458 int val2 ;
24459 int ecode2 = 0 ;
24460 PyObject *swig_obj[2] ;
24461
24462 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24464 if (!SWIG_IsOK(res1)) {
24465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24466 }
24467 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24468 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24469 if (!SWIG_IsOK(ecode2)) {
24470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24471 }
24472 arg2 = static_cast< int >(val2);
24473 if (arg1) (arg1)->m_wheelRotation = arg2;
24474
24475 resultobj = SWIG_Py_Void();
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24483 PyObject *resultobj = 0;
24484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24485 int result;
24486 void *argp1 = 0 ;
24487 int res1 = 0 ;
24488 PyObject *swig_obj[1] ;
24489
24490 if (!args) SWIG_fail;
24491 swig_obj[0] = args;
24492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24493 if (!SWIG_IsOK(res1)) {
24494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24495 }
24496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24497 result = (int) ((arg1)->m_wheelRotation);
24498 resultobj = SWIG_From_int(static_cast< int >(result));
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24506 PyObject *resultobj = 0;
24507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24508 int arg2 ;
24509 void *argp1 = 0 ;
24510 int res1 = 0 ;
24511 int val2 ;
24512 int ecode2 = 0 ;
24513 PyObject *swig_obj[2] ;
24514
24515 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24517 if (!SWIG_IsOK(res1)) {
24518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24519 }
24520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24521 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24522 if (!SWIG_IsOK(ecode2)) {
24523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24524 }
24525 arg2 = static_cast< int >(val2);
24526 if (arg1) (arg1)->m_wheelDelta = arg2;
24527
24528 resultobj = SWIG_Py_Void();
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 PyObject *resultobj = 0;
24537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24538 int result;
24539 void *argp1 = 0 ;
24540 int res1 = 0 ;
24541 PyObject *swig_obj[1] ;
24542
24543 if (!args) SWIG_fail;
24544 swig_obj[0] = args;
24545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24546 if (!SWIG_IsOK(res1)) {
24547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24548 }
24549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24550 result = (int) ((arg1)->m_wheelDelta);
24551 resultobj = SWIG_From_int(static_cast< int >(result));
24552 return resultobj;
24553 fail:
24554 return NULL;
24555 }
24556
24557
24558 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24559 PyObject *resultobj = 0;
24560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24561 int arg2 ;
24562 void *argp1 = 0 ;
24563 int res1 = 0 ;
24564 int val2 ;
24565 int ecode2 = 0 ;
24566 PyObject *swig_obj[2] ;
24567
24568 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24570 if (!SWIG_IsOK(res1)) {
24571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24572 }
24573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24574 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24575 if (!SWIG_IsOK(ecode2)) {
24576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24577 }
24578 arg2 = static_cast< int >(val2);
24579 if (arg1) (arg1)->m_linesPerAction = arg2;
24580
24581 resultobj = SWIG_Py_Void();
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24589 PyObject *resultobj = 0;
24590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24591 int result;
24592 void *argp1 = 0 ;
24593 int res1 = 0 ;
24594 PyObject *swig_obj[1] ;
24595
24596 if (!args) SWIG_fail;
24597 swig_obj[0] = args;
24598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24599 if (!SWIG_IsOK(res1)) {
24600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24601 }
24602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24603 result = (int) ((arg1)->m_linesPerAction);
24604 resultobj = SWIG_From_int(static_cast< int >(result));
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 PyObject *obj;
24613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24614 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24615 return SWIG_Py_Void();
24616 }
24617
24618 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24619 return SWIG_Python_InitShadowInstance(args);
24620 }
24621
24622 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24623 PyObject *resultobj = 0;
24624 int arg1 = (int) 0 ;
24625 int arg2 = (int) 0 ;
24626 wxSetCursorEvent *result = 0 ;
24627 int val1 ;
24628 int ecode1 = 0 ;
24629 int val2 ;
24630 int ecode2 = 0 ;
24631 PyObject * obj0 = 0 ;
24632 PyObject * obj1 = 0 ;
24633 char * kwnames[] = {
24634 (char *) "x",(char *) "y", NULL
24635 };
24636
24637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24638 if (obj0) {
24639 ecode1 = SWIG_AsVal_int(obj0, &val1);
24640 if (!SWIG_IsOK(ecode1)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24642 }
24643 arg1 = static_cast< int >(val1);
24644 }
24645 if (obj1) {
24646 ecode2 = SWIG_AsVal_int(obj1, &val2);
24647 if (!SWIG_IsOK(ecode2)) {
24648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24649 }
24650 arg2 = static_cast< int >(val2);
24651 }
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *resultobj = 0;
24667 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24668 int result;
24669 void *argp1 = 0 ;
24670 int res1 = 0 ;
24671 PyObject *swig_obj[1] ;
24672
24673 if (!args) SWIG_fail;
24674 swig_obj[0] = args;
24675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24676 if (!SWIG_IsOK(res1)) {
24677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24678 }
24679 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24680 {
24681 PyThreadState* __tstate = wxPyBeginAllowThreads();
24682 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24683 wxPyEndAllowThreads(__tstate);
24684 if (PyErr_Occurred()) SWIG_fail;
24685 }
24686 resultobj = SWIG_From_int(static_cast< int >(result));
24687 return resultobj;
24688 fail:
24689 return NULL;
24690 }
24691
24692
24693 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24694 PyObject *resultobj = 0;
24695 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24696 int result;
24697 void *argp1 = 0 ;
24698 int res1 = 0 ;
24699 PyObject *swig_obj[1] ;
24700
24701 if (!args) SWIG_fail;
24702 swig_obj[0] = args;
24703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24704 if (!SWIG_IsOK(res1)) {
24705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24706 }
24707 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 resultobj = SWIG_From_int(static_cast< int >(result));
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24722 PyObject *resultobj = 0;
24723 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24724 wxCursor *arg2 = 0 ;
24725 void *argp1 = 0 ;
24726 int res1 = 0 ;
24727 void *argp2 = 0 ;
24728 int res2 = 0 ;
24729 PyObject * obj0 = 0 ;
24730 PyObject * obj1 = 0 ;
24731 char * kwnames[] = {
24732 (char *) "self",(char *) "cursor", NULL
24733 };
24734
24735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24739 }
24740 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24742 if (!SWIG_IsOK(res2)) {
24743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24744 }
24745 if (!argp2) {
24746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24747 }
24748 arg2 = reinterpret_cast< wxCursor * >(argp2);
24749 {
24750 PyThreadState* __tstate = wxPyBeginAllowThreads();
24751 (arg1)->SetCursor((wxCursor const &)*arg2);
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 resultobj = SWIG_Py_Void();
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24763 PyObject *resultobj = 0;
24764 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24765 wxCursor *result = 0 ;
24766 void *argp1 = 0 ;
24767 int res1 = 0 ;
24768 PyObject *swig_obj[1] ;
24769
24770 if (!args) SWIG_fail;
24771 swig_obj[0] = args;
24772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24773 if (!SWIG_IsOK(res1)) {
24774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24775 }
24776 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24777 {
24778 PyThreadState* __tstate = wxPyBeginAllowThreads();
24779 {
24780 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24781 result = (wxCursor *) &_result_ref;
24782 }
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 wxCursor* resultptr = new wxCursor(*result);
24788 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24789 }
24790 return resultobj;
24791 fail:
24792 return NULL;
24793 }
24794
24795
24796 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24797 PyObject *resultobj = 0;
24798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24799 bool result;
24800 void *argp1 = 0 ;
24801 int res1 = 0 ;
24802 PyObject *swig_obj[1] ;
24803
24804 if (!args) SWIG_fail;
24805 swig_obj[0] = args;
24806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24807 if (!SWIG_IsOK(res1)) {
24808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24809 }
24810 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24811 {
24812 PyThreadState* __tstate = wxPyBeginAllowThreads();
24813 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 {
24818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24819 }
24820 return resultobj;
24821 fail:
24822 return NULL;
24823 }
24824
24825
24826 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 PyObject *obj;
24828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24829 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24830 return SWIG_Py_Void();
24831 }
24832
24833 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24834 return SWIG_Python_InitShadowInstance(args);
24835 }
24836
24837 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj = 0;
24839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24840 wxKeyEvent *result = 0 ;
24841 int val1 ;
24842 int ecode1 = 0 ;
24843 PyObject * obj0 = 0 ;
24844 char * kwnames[] = {
24845 (char *) "eventType", NULL
24846 };
24847
24848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24849 if (obj0) {
24850 ecode1 = SWIG_AsVal_int(obj0, &val1);
24851 if (!SWIG_IsOK(ecode1)) {
24852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24853 }
24854 arg1 = static_cast< wxEventType >(val1);
24855 }
24856 {
24857 PyThreadState* __tstate = wxPyBeginAllowThreads();
24858 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24863 return resultobj;
24864 fail:
24865 return NULL;
24866 }
24867
24868
24869 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24870 PyObject *resultobj = 0;
24871 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24872 int result;
24873 void *argp1 = 0 ;
24874 int res1 = 0 ;
24875 PyObject *swig_obj[1] ;
24876
24877 if (!args) SWIG_fail;
24878 swig_obj[0] = args;
24879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24880 if (!SWIG_IsOK(res1)) {
24881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24882 }
24883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24887 wxPyEndAllowThreads(__tstate);
24888 if (PyErr_Occurred()) SWIG_fail;
24889 }
24890 resultobj = SWIG_From_int(static_cast< int >(result));
24891 return resultobj;
24892 fail:
24893 return NULL;
24894 }
24895
24896
24897 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24898 PyObject *resultobj = 0;
24899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24900 bool result;
24901 void *argp1 = 0 ;
24902 int res1 = 0 ;
24903 PyObject *swig_obj[1] ;
24904
24905 if (!args) SWIG_fail;
24906 swig_obj[0] = args;
24907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24908 if (!SWIG_IsOK(res1)) {
24909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24910 }
24911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24915 wxPyEndAllowThreads(__tstate);
24916 if (PyErr_Occurred()) SWIG_fail;
24917 }
24918 {
24919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24920 }
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24928 PyObject *resultobj = 0;
24929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24930 bool result;
24931 void *argp1 = 0 ;
24932 int res1 = 0 ;
24933 PyObject *swig_obj[1] ;
24934
24935 if (!args) SWIG_fail;
24936 swig_obj[0] = args;
24937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24938 if (!SWIG_IsOK(res1)) {
24939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24940 }
24941 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24942 {
24943 PyThreadState* __tstate = wxPyBeginAllowThreads();
24944 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24945 wxPyEndAllowThreads(__tstate);
24946 if (PyErr_Occurred()) SWIG_fail;
24947 }
24948 {
24949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24950 }
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24958 PyObject *resultobj = 0;
24959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24960 bool result;
24961 void *argp1 = 0 ;
24962 int res1 = 0 ;
24963 PyObject *swig_obj[1] ;
24964
24965 if (!args) SWIG_fail;
24966 swig_obj[0] = args;
24967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24968 if (!SWIG_IsOK(res1)) {
24969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24970 }
24971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 {
24979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24980 }
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988 PyObject *resultobj = 0;
24989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24990 bool result;
24991 void *argp1 = 0 ;
24992 int res1 = 0 ;
24993 PyObject *swig_obj[1] ;
24994
24995 if (!args) SWIG_fail;
24996 swig_obj[0] = args;
24997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25000 }
25001 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 {
25009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25010 }
25011 return resultobj;
25012 fail:
25013 return NULL;
25014 }
25015
25016
25017 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25018 PyObject *resultobj = 0;
25019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25020 bool result;
25021 void *argp1 = 0 ;
25022 int res1 = 0 ;
25023 PyObject *swig_obj[1] ;
25024
25025 if (!args) SWIG_fail;
25026 swig_obj[0] = args;
25027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25028 if (!SWIG_IsOK(res1)) {
25029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25030 }
25031 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25035 wxPyEndAllowThreads(__tstate);
25036 if (PyErr_Occurred()) SWIG_fail;
25037 }
25038 {
25039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25040 }
25041 return resultobj;
25042 fail:
25043 return NULL;
25044 }
25045
25046
25047 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25048 PyObject *resultobj = 0;
25049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25050 bool result;
25051 void *argp1 = 0 ;
25052 int res1 = 0 ;
25053 PyObject *swig_obj[1] ;
25054
25055 if (!args) SWIG_fail;
25056 swig_obj[0] = args;
25057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25058 if (!SWIG_IsOK(res1)) {
25059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25060 }
25061 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25078 PyObject *resultobj = 0;
25079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25080 int result;
25081 void *argp1 = 0 ;
25082 int res1 = 0 ;
25083 PyObject *swig_obj[1] ;
25084
25085 if (!args) SWIG_fail;
25086 swig_obj[0] = args;
25087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25088 if (!SWIG_IsOK(res1)) {
25089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25090 }
25091 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25092 {
25093 PyThreadState* __tstate = wxPyBeginAllowThreads();
25094 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25095 wxPyEndAllowThreads(__tstate);
25096 if (PyErr_Occurred()) SWIG_fail;
25097 }
25098 resultobj = SWIG_From_int(static_cast< int >(result));
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25106 PyObject *resultobj = 0;
25107 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25108 int result;
25109 void *argp1 = 0 ;
25110 int res1 = 0 ;
25111 PyObject *swig_obj[1] ;
25112
25113 if (!args) SWIG_fail;
25114 swig_obj[0] = args;
25115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25116 if (!SWIG_IsOK(res1)) {
25117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25118 }
25119 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25120 {
25121 PyThreadState* __tstate = wxPyBeginAllowThreads();
25122 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 resultobj = SWIG_From_int(static_cast< int >(result));
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj = 0;
25135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25136 int arg2 ;
25137 void *argp1 = 0 ;
25138 int res1 = 0 ;
25139 int val2 ;
25140 int ecode2 = 0 ;
25141 PyObject * obj0 = 0 ;
25142 PyObject * obj1 = 0 ;
25143 char * kwnames[] = {
25144 (char *) "self",(char *) "uniChar", NULL
25145 };
25146
25147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25149 if (!SWIG_IsOK(res1)) {
25150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25151 }
25152 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25153 ecode2 = SWIG_AsVal_int(obj1, &val2);
25154 if (!SWIG_IsOK(ecode2)) {
25155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25156 }
25157 arg2 = static_cast< int >(val2);
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25161 wxPyEndAllowThreads(__tstate);
25162 if (PyErr_Occurred()) SWIG_fail;
25163 }
25164 resultobj = SWIG_Py_Void();
25165 return resultobj;
25166 fail:
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25172 PyObject *resultobj = 0;
25173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25174 unsigned int result;
25175 void *argp1 = 0 ;
25176 int res1 = 0 ;
25177 PyObject *swig_obj[1] ;
25178
25179 if (!args) SWIG_fail;
25180 swig_obj[0] = args;
25181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25182 if (!SWIG_IsOK(res1)) {
25183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25184 }
25185 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 PyObject *resultobj = 0;
25201 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25202 unsigned int result;
25203 void *argp1 = 0 ;
25204 int res1 = 0 ;
25205 PyObject *swig_obj[1] ;
25206
25207 if (!args) SWIG_fail;
25208 swig_obj[0] = args;
25209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25210 if (!SWIG_IsOK(res1)) {
25211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25212 }
25213 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25221 return resultobj;
25222 fail:
25223 return NULL;
25224 }
25225
25226
25227 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25228 PyObject *resultobj = 0;
25229 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25230 wxPoint result;
25231 void *argp1 = 0 ;
25232 int res1 = 0 ;
25233 PyObject *swig_obj[1] ;
25234
25235 if (!args) SWIG_fail;
25236 swig_obj[0] = args;
25237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25238 if (!SWIG_IsOK(res1)) {
25239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25240 }
25241 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25242 {
25243 PyThreadState* __tstate = wxPyBeginAllowThreads();
25244 result = (arg1)->GetPosition();
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25249 return resultobj;
25250 fail:
25251 return NULL;
25252 }
25253
25254
25255 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25256 PyObject *resultobj = 0;
25257 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25258 long *arg2 = (long *) 0 ;
25259 long *arg3 = (long *) 0 ;
25260 void *argp1 = 0 ;
25261 int res1 = 0 ;
25262 long temp2 ;
25263 int res2 = SWIG_TMPOBJ ;
25264 long temp3 ;
25265 int res3 = SWIG_TMPOBJ ;
25266 PyObject *swig_obj[1] ;
25267
25268 arg2 = &temp2;
25269 arg3 = &temp3;
25270 if (!args) SWIG_fail;
25271 swig_obj[0] = args;
25272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25275 }
25276 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 (arg1)->GetPosition(arg2,arg3);
25280 wxPyEndAllowThreads(__tstate);
25281 if (PyErr_Occurred()) SWIG_fail;
25282 }
25283 resultobj = SWIG_Py_Void();
25284 if (SWIG_IsTmpObj(res2)) {
25285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25286 } else {
25287 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25289 }
25290 if (SWIG_IsTmpObj(res3)) {
25291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25292 } else {
25293 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25295 }
25296 return resultobj;
25297 fail:
25298 return NULL;
25299 }
25300
25301
25302 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25303 PyObject *resultobj = 0;
25304 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25305 int result;
25306 void *argp1 = 0 ;
25307 int res1 = 0 ;
25308 PyObject *swig_obj[1] ;
25309
25310 if (!args) SWIG_fail;
25311 swig_obj[0] = args;
25312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25313 if (!SWIG_IsOK(res1)) {
25314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25315 }
25316 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25317 {
25318 PyThreadState* __tstate = wxPyBeginAllowThreads();
25319 result = (int)((wxKeyEvent const *)arg1)->GetX();
25320 wxPyEndAllowThreads(__tstate);
25321 if (PyErr_Occurred()) SWIG_fail;
25322 }
25323 resultobj = SWIG_From_int(static_cast< int >(result));
25324 return resultobj;
25325 fail:
25326 return NULL;
25327 }
25328
25329
25330 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25331 PyObject *resultobj = 0;
25332 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25333 int result;
25334 void *argp1 = 0 ;
25335 int res1 = 0 ;
25336 PyObject *swig_obj[1] ;
25337
25338 if (!args) SWIG_fail;
25339 swig_obj[0] = args;
25340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25341 if (!SWIG_IsOK(res1)) {
25342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25343 }
25344 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 result = (int)((wxKeyEvent const *)arg1)->GetY();
25348 wxPyEndAllowThreads(__tstate);
25349 if (PyErr_Occurred()) SWIG_fail;
25350 }
25351 resultobj = SWIG_From_int(static_cast< int >(result));
25352 return resultobj;
25353 fail:
25354 return NULL;
25355 }
25356
25357
25358 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25359 PyObject *resultobj = 0;
25360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25361 int arg2 ;
25362 void *argp1 = 0 ;
25363 int res1 = 0 ;
25364 int val2 ;
25365 int ecode2 = 0 ;
25366 PyObject *swig_obj[2] ;
25367
25368 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25370 if (!SWIG_IsOK(res1)) {
25371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25372 }
25373 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25374 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25375 if (!SWIG_IsOK(ecode2)) {
25376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25377 }
25378 arg2 = static_cast< int >(val2);
25379 if (arg1) (arg1)->m_x = arg2;
25380
25381 resultobj = SWIG_Py_Void();
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25389 PyObject *resultobj = 0;
25390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25391 int result;
25392 void *argp1 = 0 ;
25393 int res1 = 0 ;
25394 PyObject *swig_obj[1] ;
25395
25396 if (!args) SWIG_fail;
25397 swig_obj[0] = args;
25398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25399 if (!SWIG_IsOK(res1)) {
25400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25401 }
25402 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25403 result = (int) ((arg1)->m_x);
25404 resultobj = SWIG_From_int(static_cast< int >(result));
25405 return resultobj;
25406 fail:
25407 return NULL;
25408 }
25409
25410
25411 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25412 PyObject *resultobj = 0;
25413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25414 int arg2 ;
25415 void *argp1 = 0 ;
25416 int res1 = 0 ;
25417 int val2 ;
25418 int ecode2 = 0 ;
25419 PyObject *swig_obj[2] ;
25420
25421 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25423 if (!SWIG_IsOK(res1)) {
25424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25425 }
25426 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25427 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25428 if (!SWIG_IsOK(ecode2)) {
25429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25430 }
25431 arg2 = static_cast< int >(val2);
25432 if (arg1) (arg1)->m_y = arg2;
25433
25434 resultobj = SWIG_Py_Void();
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25442 PyObject *resultobj = 0;
25443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25444 int result;
25445 void *argp1 = 0 ;
25446 int res1 = 0 ;
25447 PyObject *swig_obj[1] ;
25448
25449 if (!args) SWIG_fail;
25450 swig_obj[0] = args;
25451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25452 if (!SWIG_IsOK(res1)) {
25453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25454 }
25455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25456 result = (int) ((arg1)->m_y);
25457 resultobj = SWIG_From_int(static_cast< int >(result));
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *resultobj = 0;
25466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25467 long arg2 ;
25468 void *argp1 = 0 ;
25469 int res1 = 0 ;
25470 long val2 ;
25471 int ecode2 = 0 ;
25472 PyObject *swig_obj[2] ;
25473
25474 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25476 if (!SWIG_IsOK(res1)) {
25477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25478 }
25479 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25480 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25481 if (!SWIG_IsOK(ecode2)) {
25482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25483 }
25484 arg2 = static_cast< long >(val2);
25485 if (arg1) (arg1)->m_keyCode = arg2;
25486
25487 resultobj = SWIG_Py_Void();
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25497 long result;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 PyObject *swig_obj[1] ;
25501
25502 if (!args) SWIG_fail;
25503 swig_obj[0] = args;
25504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25505 if (!SWIG_IsOK(res1)) {
25506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25507 }
25508 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25509 result = (long) ((arg1)->m_keyCode);
25510 resultobj = SWIG_From_long(static_cast< long >(result));
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *resultobj = 0;
25519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25520 bool arg2 ;
25521 void *argp1 = 0 ;
25522 int res1 = 0 ;
25523 bool val2 ;
25524 int ecode2 = 0 ;
25525 PyObject *swig_obj[2] ;
25526
25527 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25529 if (!SWIG_IsOK(res1)) {
25530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25531 }
25532 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25533 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25534 if (!SWIG_IsOK(ecode2)) {
25535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25536 }
25537 arg2 = static_cast< bool >(val2);
25538 if (arg1) (arg1)->m_controlDown = arg2;
25539
25540 resultobj = SWIG_Py_Void();
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25548 PyObject *resultobj = 0;
25549 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25550 bool result;
25551 void *argp1 = 0 ;
25552 int res1 = 0 ;
25553 PyObject *swig_obj[1] ;
25554
25555 if (!args) SWIG_fail;
25556 swig_obj[0] = args;
25557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25558 if (!SWIG_IsOK(res1)) {
25559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25560 }
25561 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25562 result = (bool) ((arg1)->m_controlDown);
25563 {
25564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25565 }
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *resultobj = 0;
25574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25575 bool arg2 ;
25576 void *argp1 = 0 ;
25577 int res1 = 0 ;
25578 bool val2 ;
25579 int ecode2 = 0 ;
25580 PyObject *swig_obj[2] ;
25581
25582 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25584 if (!SWIG_IsOK(res1)) {
25585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25586 }
25587 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25588 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25589 if (!SWIG_IsOK(ecode2)) {
25590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25591 }
25592 arg2 = static_cast< bool >(val2);
25593 if (arg1) (arg1)->m_shiftDown = arg2;
25594
25595 resultobj = SWIG_Py_Void();
25596 return resultobj;
25597 fail:
25598 return NULL;
25599 }
25600
25601
25602 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25603 PyObject *resultobj = 0;
25604 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25605 bool result;
25606 void *argp1 = 0 ;
25607 int res1 = 0 ;
25608 PyObject *swig_obj[1] ;
25609
25610 if (!args) SWIG_fail;
25611 swig_obj[0] = args;
25612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25613 if (!SWIG_IsOK(res1)) {
25614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25615 }
25616 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25617 result = (bool) ((arg1)->m_shiftDown);
25618 {
25619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25620 }
25621 return resultobj;
25622 fail:
25623 return NULL;
25624 }
25625
25626
25627 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25628 PyObject *resultobj = 0;
25629 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25630 bool arg2 ;
25631 void *argp1 = 0 ;
25632 int res1 = 0 ;
25633 bool val2 ;
25634 int ecode2 = 0 ;
25635 PyObject *swig_obj[2] ;
25636
25637 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25641 }
25642 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25643 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25644 if (!SWIG_IsOK(ecode2)) {
25645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25646 }
25647 arg2 = static_cast< bool >(val2);
25648 if (arg1) (arg1)->m_altDown = arg2;
25649
25650 resultobj = SWIG_Py_Void();
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *resultobj = 0;
25659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25660 bool result;
25661 void *argp1 = 0 ;
25662 int res1 = 0 ;
25663 PyObject *swig_obj[1] ;
25664
25665 if (!args) SWIG_fail;
25666 swig_obj[0] = args;
25667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25668 if (!SWIG_IsOK(res1)) {
25669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25670 }
25671 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25672 result = (bool) ((arg1)->m_altDown);
25673 {
25674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25675 }
25676 return resultobj;
25677 fail:
25678 return NULL;
25679 }
25680
25681
25682 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25683 PyObject *resultobj = 0;
25684 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25685 bool arg2 ;
25686 void *argp1 = 0 ;
25687 int res1 = 0 ;
25688 bool val2 ;
25689 int ecode2 = 0 ;
25690 PyObject *swig_obj[2] ;
25691
25692 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25694 if (!SWIG_IsOK(res1)) {
25695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25696 }
25697 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25698 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25699 if (!SWIG_IsOK(ecode2)) {
25700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25701 }
25702 arg2 = static_cast< bool >(val2);
25703 if (arg1) (arg1)->m_metaDown = arg2;
25704
25705 resultobj = SWIG_Py_Void();
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25713 PyObject *resultobj = 0;
25714 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25715 bool result;
25716 void *argp1 = 0 ;
25717 int res1 = 0 ;
25718 PyObject *swig_obj[1] ;
25719
25720 if (!args) SWIG_fail;
25721 swig_obj[0] = args;
25722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25723 if (!SWIG_IsOK(res1)) {
25724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25725 }
25726 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25727 result = (bool) ((arg1)->m_metaDown);
25728 {
25729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25738 PyObject *resultobj = 0;
25739 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25740 bool arg2 ;
25741 void *argp1 = 0 ;
25742 int res1 = 0 ;
25743 bool val2 ;
25744 int ecode2 = 0 ;
25745 PyObject *swig_obj[2] ;
25746
25747 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25749 if (!SWIG_IsOK(res1)) {
25750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25751 }
25752 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25753 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25754 if (!SWIG_IsOK(ecode2)) {
25755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25756 }
25757 arg2 = static_cast< bool >(val2);
25758 if (arg1) (arg1)->m_scanCode = arg2;
25759
25760 resultobj = SWIG_Py_Void();
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25768 PyObject *resultobj = 0;
25769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25770 bool result;
25771 void *argp1 = 0 ;
25772 int res1 = 0 ;
25773 PyObject *swig_obj[1] ;
25774
25775 if (!args) SWIG_fail;
25776 swig_obj[0] = args;
25777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25780 }
25781 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25782 result = (bool) ((arg1)->m_scanCode);
25783 {
25784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25785 }
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25793 PyObject *resultobj = 0;
25794 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25795 unsigned int arg2 ;
25796 void *argp1 = 0 ;
25797 int res1 = 0 ;
25798 unsigned int val2 ;
25799 int ecode2 = 0 ;
25800 PyObject *swig_obj[2] ;
25801
25802 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25804 if (!SWIG_IsOK(res1)) {
25805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25806 }
25807 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25808 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25809 if (!SWIG_IsOK(ecode2)) {
25810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25811 }
25812 arg2 = static_cast< unsigned int >(val2);
25813 if (arg1) (arg1)->m_rawCode = arg2;
25814
25815 resultobj = SWIG_Py_Void();
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25823 PyObject *resultobj = 0;
25824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25825 unsigned int result;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 PyObject *swig_obj[1] ;
25829
25830 if (!args) SWIG_fail;
25831 swig_obj[0] = args;
25832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25833 if (!SWIG_IsOK(res1)) {
25834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25835 }
25836 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25837 result = (unsigned int) ((arg1)->m_rawCode);
25838 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25839 return resultobj;
25840 fail:
25841 return NULL;
25842 }
25843
25844
25845 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25846 PyObject *resultobj = 0;
25847 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25848 unsigned int arg2 ;
25849 void *argp1 = 0 ;
25850 int res1 = 0 ;
25851 unsigned int val2 ;
25852 int ecode2 = 0 ;
25853 PyObject *swig_obj[2] ;
25854
25855 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25857 if (!SWIG_IsOK(res1)) {
25858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25859 }
25860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25861 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25862 if (!SWIG_IsOK(ecode2)) {
25863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25864 }
25865 arg2 = static_cast< unsigned int >(val2);
25866 if (arg1) (arg1)->m_rawFlags = arg2;
25867
25868 resultobj = SWIG_Py_Void();
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25876 PyObject *resultobj = 0;
25877 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25878 unsigned int result;
25879 void *argp1 = 0 ;
25880 int res1 = 0 ;
25881 PyObject *swig_obj[1] ;
25882
25883 if (!args) SWIG_fail;
25884 swig_obj[0] = args;
25885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25886 if (!SWIG_IsOK(res1)) {
25887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25888 }
25889 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25890 result = (unsigned int) ((arg1)->m_rawFlags);
25891 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 PyObject *obj;
25900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25901 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25902 return SWIG_Py_Void();
25903 }
25904
25905 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25906 return SWIG_Python_InitShadowInstance(args);
25907 }
25908
25909 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj = 0;
25911 wxSize const &arg1_defvalue = wxDefaultSize ;
25912 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25913 int arg2 = (int) 0 ;
25914 wxSizeEvent *result = 0 ;
25915 wxSize temp1 ;
25916 int val2 ;
25917 int ecode2 = 0 ;
25918 PyObject * obj0 = 0 ;
25919 PyObject * obj1 = 0 ;
25920 char * kwnames[] = {
25921 (char *) "sz",(char *) "winid", NULL
25922 };
25923
25924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25925 if (obj0) {
25926 {
25927 arg1 = &temp1;
25928 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25929 }
25930 }
25931 if (obj1) {
25932 ecode2 = SWIG_AsVal_int(obj1, &val2);
25933 if (!SWIG_IsOK(ecode2)) {
25934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25935 }
25936 arg2 = static_cast< int >(val2);
25937 }
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25941 wxPyEndAllowThreads(__tstate);
25942 if (PyErr_Occurred()) SWIG_fail;
25943 }
25944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25952 PyObject *resultobj = 0;
25953 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25954 wxSize 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_wxSizeEvent, 0 | 0 );
25962 if (!SWIG_IsOK(res1)) {
25963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25964 }
25965 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 result = ((wxSizeEvent const *)arg1)->GetSize();
25969 wxPyEndAllowThreads(__tstate);
25970 if (PyErr_Occurred()) SWIG_fail;
25971 }
25972 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25973 return resultobj;
25974 fail:
25975 return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25980 PyObject *resultobj = 0;
25981 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25982 wxRect result;
25983 void *argp1 = 0 ;
25984 int res1 = 0 ;
25985 PyObject *swig_obj[1] ;
25986
25987 if (!args) SWIG_fail;
25988 swig_obj[0] = args;
25989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25990 if (!SWIG_IsOK(res1)) {
25991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25992 }
25993 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 result = ((wxSizeEvent const *)arg1)->GetRect();
25997 wxPyEndAllowThreads(__tstate);
25998 if (PyErr_Occurred()) SWIG_fail;
25999 }
26000 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26001 return resultobj;
26002 fail:
26003 return NULL;
26004 }
26005
26006
26007 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26008 PyObject *resultobj = 0;
26009 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26010 wxRect arg2 ;
26011 void *argp1 = 0 ;
26012 int res1 = 0 ;
26013 void *argp2 ;
26014 int res2 = 0 ;
26015 PyObject * obj0 = 0 ;
26016 PyObject * obj1 = 0 ;
26017 char * kwnames[] = {
26018 (char *) "self",(char *) "rect", NULL
26019 };
26020
26021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26023 if (!SWIG_IsOK(res1)) {
26024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26025 }
26026 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26027 {
26028 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26029 if (!SWIG_IsOK(res2)) {
26030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26031 }
26032 if (!argp2) {
26033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26034 } else {
26035 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26036 arg2 = *temp;
26037 if (SWIG_IsNewObj(res2)) delete temp;
26038 }
26039 }
26040 {
26041 PyThreadState* __tstate = wxPyBeginAllowThreads();
26042 (arg1)->SetRect(arg2);
26043 wxPyEndAllowThreads(__tstate);
26044 if (PyErr_Occurred()) SWIG_fail;
26045 }
26046 resultobj = SWIG_Py_Void();
26047 return resultobj;
26048 fail:
26049 return NULL;
26050 }
26051
26052
26053 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26054 PyObject *resultobj = 0;
26055 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26056 wxSize arg2 ;
26057 void *argp1 = 0 ;
26058 int res1 = 0 ;
26059 void *argp2 ;
26060 int res2 = 0 ;
26061 PyObject * obj0 = 0 ;
26062 PyObject * obj1 = 0 ;
26063 char * kwnames[] = {
26064 (char *) "self",(char *) "size", NULL
26065 };
26066
26067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26069 if (!SWIG_IsOK(res1)) {
26070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26071 }
26072 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26073 {
26074 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26075 if (!SWIG_IsOK(res2)) {
26076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26077 }
26078 if (!argp2) {
26079 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26080 } else {
26081 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26082 arg2 = *temp;
26083 if (SWIG_IsNewObj(res2)) delete temp;
26084 }
26085 }
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 wxSizeEvent_SetSize(arg1,arg2);
26089 wxPyEndAllowThreads(__tstate);
26090 if (PyErr_Occurred()) SWIG_fail;
26091 }
26092 resultobj = SWIG_Py_Void();
26093 return resultobj;
26094 fail:
26095 return NULL;
26096 }
26097
26098
26099 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26100 PyObject *resultobj = 0;
26101 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26102 wxSize *arg2 = (wxSize *) 0 ;
26103 void *argp1 = 0 ;
26104 int res1 = 0 ;
26105 void *argp2 = 0 ;
26106 int res2 = 0 ;
26107 PyObject *swig_obj[2] ;
26108
26109 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26111 if (!SWIG_IsOK(res1)) {
26112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26113 }
26114 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26115 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26116 if (!SWIG_IsOK(res2)) {
26117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26118 }
26119 arg2 = reinterpret_cast< wxSize * >(argp2);
26120 if (arg1) (arg1)->m_size = *arg2;
26121
26122 resultobj = SWIG_Py_Void();
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *resultobj = 0;
26131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26132 wxSize *result = 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 PyObject *swig_obj[1] ;
26136
26137 if (!args) SWIG_fail;
26138 swig_obj[0] = args;
26139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26140 if (!SWIG_IsOK(res1)) {
26141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26142 }
26143 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26144 result = (wxSize *)& ((arg1)->m_size);
26145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26153 PyObject *resultobj = 0;
26154 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26155 wxRect *arg2 = (wxRect *) 0 ;
26156 void *argp1 = 0 ;
26157 int res1 = 0 ;
26158 void *argp2 = 0 ;
26159 int res2 = 0 ;
26160 PyObject *swig_obj[2] ;
26161
26162 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26164 if (!SWIG_IsOK(res1)) {
26165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26166 }
26167 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26168 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26169 if (!SWIG_IsOK(res2)) {
26170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26171 }
26172 arg2 = reinterpret_cast< wxRect * >(argp2);
26173 if (arg1) (arg1)->m_rect = *arg2;
26174
26175 resultobj = SWIG_Py_Void();
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26183 PyObject *resultobj = 0;
26184 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26185 wxRect *result = 0 ;
26186 void *argp1 = 0 ;
26187 int res1 = 0 ;
26188 PyObject *swig_obj[1] ;
26189
26190 if (!args) SWIG_fail;
26191 swig_obj[0] = args;
26192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26193 if (!SWIG_IsOK(res1)) {
26194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26195 }
26196 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26197 result = (wxRect *)& ((arg1)->m_rect);
26198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26206 PyObject *obj;
26207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26208 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26209 return SWIG_Py_Void();
26210 }
26211
26212 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26213 return SWIG_Python_InitShadowInstance(args);
26214 }
26215
26216 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj = 0;
26218 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26219 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26220 int arg2 = (int) 0 ;
26221 wxMoveEvent *result = 0 ;
26222 wxPoint temp1 ;
26223 int val2 ;
26224 int ecode2 = 0 ;
26225 PyObject * obj0 = 0 ;
26226 PyObject * obj1 = 0 ;
26227 char * kwnames[] = {
26228 (char *) "pos",(char *) "winid", NULL
26229 };
26230
26231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26232 if (obj0) {
26233 {
26234 arg1 = &temp1;
26235 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26236 }
26237 }
26238 if (obj1) {
26239 ecode2 = SWIG_AsVal_int(obj1, &val2);
26240 if (!SWIG_IsOK(ecode2)) {
26241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26242 }
26243 arg2 = static_cast< int >(val2);
26244 }
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26248 wxPyEndAllowThreads(__tstate);
26249 if (PyErr_Occurred()) SWIG_fail;
26250 }
26251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *resultobj = 0;
26260 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26261 wxPoint result;
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_wxMoveEvent, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26271 }
26272 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26273 {
26274 PyThreadState* __tstate = wxPyBeginAllowThreads();
26275 result = ((wxMoveEvent const *)arg1)->GetPosition();
26276 wxPyEndAllowThreads(__tstate);
26277 if (PyErr_Occurred()) SWIG_fail;
26278 }
26279 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26287 PyObject *resultobj = 0;
26288 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26289 wxRect result;
26290 void *argp1 = 0 ;
26291 int res1 = 0 ;
26292 PyObject *swig_obj[1] ;
26293
26294 if (!args) SWIG_fail;
26295 swig_obj[0] = args;
26296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26297 if (!SWIG_IsOK(res1)) {
26298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26299 }
26300 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = ((wxMoveEvent const *)arg1)->GetRect();
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26308 return resultobj;
26309 fail:
26310 return NULL;
26311 }
26312
26313
26314 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26315 PyObject *resultobj = 0;
26316 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26317 wxRect *arg2 = 0 ;
26318 void *argp1 = 0 ;
26319 int res1 = 0 ;
26320 wxRect temp2 ;
26321 PyObject * obj0 = 0 ;
26322 PyObject * obj1 = 0 ;
26323 char * kwnames[] = {
26324 (char *) "self",(char *) "rect", NULL
26325 };
26326
26327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26331 }
26332 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26333 {
26334 arg2 = &temp2;
26335 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26336 }
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 (arg1)->SetRect((wxRect const &)*arg2);
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 resultobj = SWIG_Py_Void();
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26351 PyObject *resultobj = 0;
26352 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26353 wxPoint *arg2 = 0 ;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 wxPoint temp2 ;
26357 PyObject * obj0 = 0 ;
26358 PyObject * obj1 = 0 ;
26359 char * kwnames[] = {
26360 (char *) "self",(char *) "pos", NULL
26361 };
26362
26363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26365 if (!SWIG_IsOK(res1)) {
26366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26367 }
26368 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26369 {
26370 arg2 = &temp2;
26371 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26372 }
26373 {
26374 PyThreadState* __tstate = wxPyBeginAllowThreads();
26375 (arg1)->SetPosition((wxPoint const &)*arg2);
26376 wxPyEndAllowThreads(__tstate);
26377 if (PyErr_Occurred()) SWIG_fail;
26378 }
26379 resultobj = SWIG_Py_Void();
26380 return resultobj;
26381 fail:
26382 return NULL;
26383 }
26384
26385
26386 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26387 PyObject *obj;
26388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26389 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26390 return SWIG_Py_Void();
26391 }
26392
26393 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26394 return SWIG_Python_InitShadowInstance(args);
26395 }
26396
26397 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26398 PyObject *resultobj = 0;
26399 int arg1 = (int) 0 ;
26400 wxPaintEvent *result = 0 ;
26401 int val1 ;
26402 int ecode1 = 0 ;
26403 PyObject * obj0 = 0 ;
26404 char * kwnames[] = {
26405 (char *) "Id", NULL
26406 };
26407
26408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26409 if (obj0) {
26410 ecode1 = SWIG_AsVal_int(obj0, &val1);
26411 if (!SWIG_IsOK(ecode1)) {
26412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26413 }
26414 arg1 = static_cast< int >(val1);
26415 }
26416 {
26417 PyThreadState* __tstate = wxPyBeginAllowThreads();
26418 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26419 wxPyEndAllowThreads(__tstate);
26420 if (PyErr_Occurred()) SWIG_fail;
26421 }
26422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26423 return resultobj;
26424 fail:
26425 return NULL;
26426 }
26427
26428
26429 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26430 PyObject *obj;
26431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26432 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26433 return SWIG_Py_Void();
26434 }
26435
26436 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26437 return SWIG_Python_InitShadowInstance(args);
26438 }
26439
26440 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26441 PyObject *resultobj = 0;
26442 int arg1 = (int) 0 ;
26443 wxNcPaintEvent *result = 0 ;
26444 int val1 ;
26445 int ecode1 = 0 ;
26446 PyObject * obj0 = 0 ;
26447 char * kwnames[] = {
26448 (char *) "winid", NULL
26449 };
26450
26451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26452 if (obj0) {
26453 ecode1 = SWIG_AsVal_int(obj0, &val1);
26454 if (!SWIG_IsOK(ecode1)) {
26455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26456 }
26457 arg1 = static_cast< int >(val1);
26458 }
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 PyObject *obj;
26474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26475 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26476 return SWIG_Py_Void();
26477 }
26478
26479 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26480 return SWIG_Python_InitShadowInstance(args);
26481 }
26482
26483 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 int arg1 = (int) 0 ;
26486 wxDC *arg2 = (wxDC *) NULL ;
26487 wxEraseEvent *result = 0 ;
26488 int val1 ;
26489 int ecode1 = 0 ;
26490 void *argp2 = 0 ;
26491 int res2 = 0 ;
26492 PyObject * obj0 = 0 ;
26493 PyObject * obj1 = 0 ;
26494 char * kwnames[] = {
26495 (char *) "Id",(char *) "dc", NULL
26496 };
26497
26498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26499 if (obj0) {
26500 ecode1 = SWIG_AsVal_int(obj0, &val1);
26501 if (!SWIG_IsOK(ecode1)) {
26502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26503 }
26504 arg1 = static_cast< int >(val1);
26505 }
26506 if (obj1) {
26507 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26508 if (!SWIG_IsOK(res2)) {
26509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26510 }
26511 arg2 = reinterpret_cast< wxDC * >(argp2);
26512 }
26513 {
26514 PyThreadState* __tstate = wxPyBeginAllowThreads();
26515 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26516 wxPyEndAllowThreads(__tstate);
26517 if (PyErr_Occurred()) SWIG_fail;
26518 }
26519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26527 PyObject *resultobj = 0;
26528 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26529 wxDC *result = 0 ;
26530 void *argp1 = 0 ;
26531 int res1 = 0 ;
26532 PyObject *swig_obj[1] ;
26533
26534 if (!args) SWIG_fail;
26535 swig_obj[0] = args;
26536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26537 if (!SWIG_IsOK(res1)) {
26538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26539 }
26540 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26541 {
26542 PyThreadState* __tstate = wxPyBeginAllowThreads();
26543 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26544 wxPyEndAllowThreads(__tstate);
26545 if (PyErr_Occurred()) SWIG_fail;
26546 }
26547 {
26548 resultobj = wxPyMake_wxObject(result, (bool)0);
26549 }
26550 return resultobj;
26551 fail:
26552 return NULL;
26553 }
26554
26555
26556 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 PyObject *obj;
26558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26559 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26560 return SWIG_Py_Void();
26561 }
26562
26563 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 return SWIG_Python_InitShadowInstance(args);
26565 }
26566
26567 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj = 0;
26569 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26570 int arg2 = (int) 0 ;
26571 wxFocusEvent *result = 0 ;
26572 int val1 ;
26573 int ecode1 = 0 ;
26574 int val2 ;
26575 int ecode2 = 0 ;
26576 PyObject * obj0 = 0 ;
26577 PyObject * obj1 = 0 ;
26578 char * kwnames[] = {
26579 (char *) "type",(char *) "winid", NULL
26580 };
26581
26582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26583 if (obj0) {
26584 ecode1 = SWIG_AsVal_int(obj0, &val1);
26585 if (!SWIG_IsOK(ecode1)) {
26586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26587 }
26588 arg1 = static_cast< wxEventType >(val1);
26589 }
26590 if (obj1) {
26591 ecode2 = SWIG_AsVal_int(obj1, &val2);
26592 if (!SWIG_IsOK(ecode2)) {
26593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26594 }
26595 arg2 = static_cast< int >(val2);
26596 }
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26600 wxPyEndAllowThreads(__tstate);
26601 if (PyErr_Occurred()) SWIG_fail;
26602 }
26603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26604 return resultobj;
26605 fail:
26606 return NULL;
26607 }
26608
26609
26610 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26611 PyObject *resultobj = 0;
26612 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26613 wxWindow *result = 0 ;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 PyObject *swig_obj[1] ;
26617
26618 if (!args) SWIG_fail;
26619 swig_obj[0] = args;
26620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26621 if (!SWIG_IsOK(res1)) {
26622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26623 }
26624 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26628 wxPyEndAllowThreads(__tstate);
26629 if (PyErr_Occurred()) SWIG_fail;
26630 }
26631 {
26632 resultobj = wxPyMake_wxObject(result, (bool)0);
26633 }
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj = 0;
26642 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26643 wxWindow *arg2 = (wxWindow *) 0 ;
26644 void *argp1 = 0 ;
26645 int res1 = 0 ;
26646 void *argp2 = 0 ;
26647 int res2 = 0 ;
26648 PyObject * obj0 = 0 ;
26649 PyObject * obj1 = 0 ;
26650 char * kwnames[] = {
26651 (char *) "self",(char *) "win", NULL
26652 };
26653
26654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26656 if (!SWIG_IsOK(res1)) {
26657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26658 }
26659 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26661 if (!SWIG_IsOK(res2)) {
26662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26663 }
26664 arg2 = reinterpret_cast< wxWindow * >(argp2);
26665 {
26666 PyThreadState* __tstate = wxPyBeginAllowThreads();
26667 (arg1)->SetWindow(arg2);
26668 wxPyEndAllowThreads(__tstate);
26669 if (PyErr_Occurred()) SWIG_fail;
26670 }
26671 resultobj = SWIG_Py_Void();
26672 return resultobj;
26673 fail:
26674 return NULL;
26675 }
26676
26677
26678 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679 PyObject *obj;
26680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26681 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26682 return SWIG_Py_Void();
26683 }
26684
26685 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26686 return SWIG_Python_InitShadowInstance(args);
26687 }
26688
26689 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26690 PyObject *resultobj = 0;
26691 wxWindow *arg1 = (wxWindow *) NULL ;
26692 wxChildFocusEvent *result = 0 ;
26693 void *argp1 = 0 ;
26694 int res1 = 0 ;
26695 PyObject * obj0 = 0 ;
26696 char * kwnames[] = {
26697 (char *) "win", NULL
26698 };
26699
26700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26701 if (obj0) {
26702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26703 if (!SWIG_IsOK(res1)) {
26704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26705 }
26706 arg1 = reinterpret_cast< wxWindow * >(argp1);
26707 }
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 PyObject *resultobj = 0;
26723 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26724 wxWindow *result = 0 ;
26725 void *argp1 = 0 ;
26726 int res1 = 0 ;
26727 PyObject *swig_obj[1] ;
26728
26729 if (!args) SWIG_fail;
26730 swig_obj[0] = args;
26731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26732 if (!SWIG_IsOK(res1)) {
26733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26734 }
26735 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 {
26743 resultobj = wxPyMake_wxObject(result, (bool)0);
26744 }
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26752 PyObject *obj;
26753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26754 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26755 return SWIG_Py_Void();
26756 }
26757
26758 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 return SWIG_Python_InitShadowInstance(args);
26760 }
26761
26762 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26763 PyObject *resultobj = 0;
26764 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26765 bool arg2 = (bool) true ;
26766 int arg3 = (int) 0 ;
26767 wxActivateEvent *result = 0 ;
26768 int val1 ;
26769 int ecode1 = 0 ;
26770 bool val2 ;
26771 int ecode2 = 0 ;
26772 int val3 ;
26773 int ecode3 = 0 ;
26774 PyObject * obj0 = 0 ;
26775 PyObject * obj1 = 0 ;
26776 PyObject * obj2 = 0 ;
26777 char * kwnames[] = {
26778 (char *) "type",(char *) "active",(char *) "Id", NULL
26779 };
26780
26781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26782 if (obj0) {
26783 ecode1 = SWIG_AsVal_int(obj0, &val1);
26784 if (!SWIG_IsOK(ecode1)) {
26785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26786 }
26787 arg1 = static_cast< wxEventType >(val1);
26788 }
26789 if (obj1) {
26790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26791 if (!SWIG_IsOK(ecode2)) {
26792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26793 }
26794 arg2 = static_cast< bool >(val2);
26795 }
26796 if (obj2) {
26797 ecode3 = SWIG_AsVal_int(obj2, &val3);
26798 if (!SWIG_IsOK(ecode3)) {
26799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26800 }
26801 arg3 = static_cast< int >(val3);
26802 }
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26806 wxPyEndAllowThreads(__tstate);
26807 if (PyErr_Occurred()) SWIG_fail;
26808 }
26809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26810 return resultobj;
26811 fail:
26812 return NULL;
26813 }
26814
26815
26816 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26817 PyObject *resultobj = 0;
26818 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26819 bool result;
26820 void *argp1 = 0 ;
26821 int res1 = 0 ;
26822 PyObject *swig_obj[1] ;
26823
26824 if (!args) SWIG_fail;
26825 swig_obj[0] = args;
26826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26827 if (!SWIG_IsOK(res1)) {
26828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26829 }
26830 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26831 {
26832 PyThreadState* __tstate = wxPyBeginAllowThreads();
26833 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26834 wxPyEndAllowThreads(__tstate);
26835 if (PyErr_Occurred()) SWIG_fail;
26836 }
26837 {
26838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26839 }
26840 return resultobj;
26841 fail:
26842 return NULL;
26843 }
26844
26845
26846 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26847 PyObject *obj;
26848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26849 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26850 return SWIG_Py_Void();
26851 }
26852
26853 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26854 return SWIG_Python_InitShadowInstance(args);
26855 }
26856
26857 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26858 PyObject *resultobj = 0;
26859 int arg1 = (int) 0 ;
26860 wxInitDialogEvent *result = 0 ;
26861 int val1 ;
26862 int ecode1 = 0 ;
26863 PyObject * obj0 = 0 ;
26864 char * kwnames[] = {
26865 (char *) "Id", NULL
26866 };
26867
26868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26869 if (obj0) {
26870 ecode1 = SWIG_AsVal_int(obj0, &val1);
26871 if (!SWIG_IsOK(ecode1)) {
26872 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26873 }
26874 arg1 = static_cast< int >(val1);
26875 }
26876 {
26877 PyThreadState* __tstate = wxPyBeginAllowThreads();
26878 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26879 wxPyEndAllowThreads(__tstate);
26880 if (PyErr_Occurred()) SWIG_fail;
26881 }
26882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26883 return resultobj;
26884 fail:
26885 return NULL;
26886 }
26887
26888
26889 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26890 PyObject *obj;
26891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26892 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26893 return SWIG_Py_Void();
26894 }
26895
26896 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26897 return SWIG_Python_InitShadowInstance(args);
26898 }
26899
26900 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj = 0;
26902 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26903 int arg2 = (int) 0 ;
26904 wxMenu *arg3 = (wxMenu *) NULL ;
26905 wxMenuEvent *result = 0 ;
26906 int val1 ;
26907 int ecode1 = 0 ;
26908 int val2 ;
26909 int ecode2 = 0 ;
26910 void *argp3 = 0 ;
26911 int res3 = 0 ;
26912 PyObject * obj0 = 0 ;
26913 PyObject * obj1 = 0 ;
26914 PyObject * obj2 = 0 ;
26915 char * kwnames[] = {
26916 (char *) "type",(char *) "winid",(char *) "menu", NULL
26917 };
26918
26919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26920 if (obj0) {
26921 ecode1 = SWIG_AsVal_int(obj0, &val1);
26922 if (!SWIG_IsOK(ecode1)) {
26923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26924 }
26925 arg1 = static_cast< wxEventType >(val1);
26926 }
26927 if (obj1) {
26928 ecode2 = SWIG_AsVal_int(obj1, &val2);
26929 if (!SWIG_IsOK(ecode2)) {
26930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26931 }
26932 arg2 = static_cast< int >(val2);
26933 }
26934 if (obj2) {
26935 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26936 if (!SWIG_IsOK(res3)) {
26937 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26938 }
26939 arg3 = reinterpret_cast< wxMenu * >(argp3);
26940 }
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26944 wxPyEndAllowThreads(__tstate);
26945 if (PyErr_Occurred()) SWIG_fail;
26946 }
26947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26948 return resultobj;
26949 fail:
26950 return NULL;
26951 }
26952
26953
26954 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26955 PyObject *resultobj = 0;
26956 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26957 int result;
26958 void *argp1 = 0 ;
26959 int res1 = 0 ;
26960 PyObject *swig_obj[1] ;
26961
26962 if (!args) SWIG_fail;
26963 swig_obj[0] = args;
26964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26965 if (!SWIG_IsOK(res1)) {
26966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26967 }
26968 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26969 {
26970 PyThreadState* __tstate = wxPyBeginAllowThreads();
26971 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 resultobj = SWIG_From_int(static_cast< int >(result));
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26983 PyObject *resultobj = 0;
26984 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26985 bool result;
26986 void *argp1 = 0 ;
26987 int res1 = 0 ;
26988 PyObject *swig_obj[1] ;
26989
26990 if (!args) SWIG_fail;
26991 swig_obj[0] = args;
26992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26995 }
26996 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26997 {
26998 PyThreadState* __tstate = wxPyBeginAllowThreads();
26999 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 {
27004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27005 }
27006 return resultobj;
27007 fail:
27008 return NULL;
27009 }
27010
27011
27012 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27013 PyObject *resultobj = 0;
27014 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27015 wxMenu *result = 0 ;
27016 void *argp1 = 0 ;
27017 int res1 = 0 ;
27018 PyObject *swig_obj[1] ;
27019
27020 if (!args) SWIG_fail;
27021 swig_obj[0] = args;
27022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27023 if (!SWIG_IsOK(res1)) {
27024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27025 }
27026 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 {
27034 resultobj = wxPyMake_wxObject(result, (bool)0);
27035 }
27036 return resultobj;
27037 fail:
27038 return NULL;
27039 }
27040
27041
27042 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 PyObject *obj;
27044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27045 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27046 return SWIG_Py_Void();
27047 }
27048
27049 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27050 return SWIG_Python_InitShadowInstance(args);
27051 }
27052
27053 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj = 0;
27055 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27056 int arg2 = (int) 0 ;
27057 wxCloseEvent *result = 0 ;
27058 int val1 ;
27059 int ecode1 = 0 ;
27060 int val2 ;
27061 int ecode2 = 0 ;
27062 PyObject * obj0 = 0 ;
27063 PyObject * obj1 = 0 ;
27064 char * kwnames[] = {
27065 (char *) "type",(char *) "winid", NULL
27066 };
27067
27068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27069 if (obj0) {
27070 ecode1 = SWIG_AsVal_int(obj0, &val1);
27071 if (!SWIG_IsOK(ecode1)) {
27072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27073 }
27074 arg1 = static_cast< wxEventType >(val1);
27075 }
27076 if (obj1) {
27077 ecode2 = SWIG_AsVal_int(obj1, &val2);
27078 if (!SWIG_IsOK(ecode2)) {
27079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27080 }
27081 arg2 = static_cast< int >(val2);
27082 }
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj = 0;
27098 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27099 bool arg2 ;
27100 void *argp1 = 0 ;
27101 int res1 = 0 ;
27102 bool val2 ;
27103 int ecode2 = 0 ;
27104 PyObject * obj0 = 0 ;
27105 PyObject * obj1 = 0 ;
27106 char * kwnames[] = {
27107 (char *) "self",(char *) "logOff", NULL
27108 };
27109
27110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27114 }
27115 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27117 if (!SWIG_IsOK(ecode2)) {
27118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27119 }
27120 arg2 = static_cast< bool >(val2);
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 (arg1)->SetLoggingOff(arg2);
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 resultobj = SWIG_Py_Void();
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27135 PyObject *resultobj = 0;
27136 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27137 bool result;
27138 void *argp1 = 0 ;
27139 int res1 = 0 ;
27140 PyObject *swig_obj[1] ;
27141
27142 if (!args) SWIG_fail;
27143 swig_obj[0] = args;
27144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27145 if (!SWIG_IsOK(res1)) {
27146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27147 }
27148 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27149 {
27150 PyThreadState* __tstate = wxPyBeginAllowThreads();
27151 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27152 wxPyEndAllowThreads(__tstate);
27153 if (PyErr_Occurred()) SWIG_fail;
27154 }
27155 {
27156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27157 }
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj = 0;
27166 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27167 bool arg2 = (bool) true ;
27168 void *argp1 = 0 ;
27169 int res1 = 0 ;
27170 bool val2 ;
27171 int ecode2 = 0 ;
27172 PyObject * obj0 = 0 ;
27173 PyObject * obj1 = 0 ;
27174 char * kwnames[] = {
27175 (char *) "self",(char *) "veto", NULL
27176 };
27177
27178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27180 if (!SWIG_IsOK(res1)) {
27181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27182 }
27183 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27184 if (obj1) {
27185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27186 if (!SWIG_IsOK(ecode2)) {
27187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27188 }
27189 arg2 = static_cast< bool >(val2);
27190 }
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 (arg1)->Veto(arg2);
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 resultobj = SWIG_Py_Void();
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27205 PyObject *resultobj = 0;
27206 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27207 bool result;
27208 void *argp1 = 0 ;
27209 int res1 = 0 ;
27210 PyObject *swig_obj[1] ;
27211
27212 if (!args) SWIG_fail;
27213 swig_obj[0] = args;
27214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27215 if (!SWIG_IsOK(res1)) {
27216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27217 }
27218 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27219 {
27220 PyThreadState* __tstate = wxPyBeginAllowThreads();
27221 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27222 wxPyEndAllowThreads(__tstate);
27223 if (PyErr_Occurred()) SWIG_fail;
27224 }
27225 {
27226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27227 }
27228 return resultobj;
27229 fail:
27230 return NULL;
27231 }
27232
27233
27234 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27235 PyObject *resultobj = 0;
27236 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27237 bool arg2 ;
27238 void *argp1 = 0 ;
27239 int res1 = 0 ;
27240 bool val2 ;
27241 int ecode2 = 0 ;
27242 PyObject * obj0 = 0 ;
27243 PyObject * obj1 = 0 ;
27244 char * kwnames[] = {
27245 (char *) "self",(char *) "canVeto", NULL
27246 };
27247
27248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27252 }
27253 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27254 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27255 if (!SWIG_IsOK(ecode2)) {
27256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27257 }
27258 arg2 = static_cast< bool >(val2);
27259 {
27260 PyThreadState* __tstate = wxPyBeginAllowThreads();
27261 (arg1)->SetCanVeto(arg2);
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 resultobj = SWIG_Py_Void();
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27273 PyObject *resultobj = 0;
27274 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27275 bool result;
27276 void *argp1 = 0 ;
27277 int res1 = 0 ;
27278 PyObject *swig_obj[1] ;
27279
27280 if (!args) SWIG_fail;
27281 swig_obj[0] = args;
27282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27283 if (!SWIG_IsOK(res1)) {
27284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27285 }
27286 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27287 {
27288 PyThreadState* __tstate = wxPyBeginAllowThreads();
27289 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27290 wxPyEndAllowThreads(__tstate);
27291 if (PyErr_Occurred()) SWIG_fail;
27292 }
27293 {
27294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27295 }
27296 return resultobj;
27297 fail:
27298 return NULL;
27299 }
27300
27301
27302 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27303 PyObject *obj;
27304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27305 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27306 return SWIG_Py_Void();
27307 }
27308
27309 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27310 return SWIG_Python_InitShadowInstance(args);
27311 }
27312
27313 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27314 PyObject *resultobj = 0;
27315 int arg1 = (int) 0 ;
27316 bool arg2 = (bool) false ;
27317 wxShowEvent *result = 0 ;
27318 int val1 ;
27319 int ecode1 = 0 ;
27320 bool val2 ;
27321 int ecode2 = 0 ;
27322 PyObject * obj0 = 0 ;
27323 PyObject * obj1 = 0 ;
27324 char * kwnames[] = {
27325 (char *) "winid",(char *) "show", NULL
27326 };
27327
27328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27329 if (obj0) {
27330 ecode1 = SWIG_AsVal_int(obj0, &val1);
27331 if (!SWIG_IsOK(ecode1)) {
27332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27333 }
27334 arg1 = static_cast< int >(val1);
27335 }
27336 if (obj1) {
27337 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27338 if (!SWIG_IsOK(ecode2)) {
27339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27340 }
27341 arg2 = static_cast< bool >(val2);
27342 }
27343 {
27344 PyThreadState* __tstate = wxPyBeginAllowThreads();
27345 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27346 wxPyEndAllowThreads(__tstate);
27347 if (PyErr_Occurred()) SWIG_fail;
27348 }
27349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27357 PyObject *resultobj = 0;
27358 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27359 bool arg2 ;
27360 void *argp1 = 0 ;
27361 int res1 = 0 ;
27362 bool val2 ;
27363 int ecode2 = 0 ;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 char * kwnames[] = {
27367 (char *) "self",(char *) "show", NULL
27368 };
27369
27370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27372 if (!SWIG_IsOK(res1)) {
27373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27374 }
27375 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27376 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27377 if (!SWIG_IsOK(ecode2)) {
27378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27379 }
27380 arg2 = static_cast< bool >(val2);
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 (arg1)->SetShow(arg2);
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 resultobj = SWIG_Py_Void();
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *resultobj = 0;
27396 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27397 bool result;
27398 void *argp1 = 0 ;
27399 int res1 = 0 ;
27400 PyObject *swig_obj[1] ;
27401
27402 if (!args) SWIG_fail;
27403 swig_obj[0] = args;
27404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27405 if (!SWIG_IsOK(res1)) {
27406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27407 }
27408 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 {
27416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27417 }
27418 return resultobj;
27419 fail:
27420 return NULL;
27421 }
27422
27423
27424 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 PyObject *obj;
27426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27427 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27428 return SWIG_Py_Void();
27429 }
27430
27431 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27432 return SWIG_Python_InitShadowInstance(args);
27433 }
27434
27435 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj = 0;
27437 int arg1 = (int) 0 ;
27438 bool arg2 = (bool) true ;
27439 wxIconizeEvent *result = 0 ;
27440 int val1 ;
27441 int ecode1 = 0 ;
27442 bool val2 ;
27443 int ecode2 = 0 ;
27444 PyObject * obj0 = 0 ;
27445 PyObject * obj1 = 0 ;
27446 char * kwnames[] = {
27447 (char *) "id",(char *) "iconized", NULL
27448 };
27449
27450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27451 if (obj0) {
27452 ecode1 = SWIG_AsVal_int(obj0, &val1);
27453 if (!SWIG_IsOK(ecode1)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27455 }
27456 arg1 = static_cast< int >(val1);
27457 }
27458 if (obj1) {
27459 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27460 if (!SWIG_IsOK(ecode2)) {
27461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27462 }
27463 arg2 = static_cast< bool >(val2);
27464 }
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27479 PyObject *resultobj = 0;
27480 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27481 bool result;
27482 void *argp1 = 0 ;
27483 int res1 = 0 ;
27484 PyObject *swig_obj[1] ;
27485
27486 if (!args) SWIG_fail;
27487 swig_obj[0] = args;
27488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27489 if (!SWIG_IsOK(res1)) {
27490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27491 }
27492 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27493 {
27494 PyThreadState* __tstate = wxPyBeginAllowThreads();
27495 result = (bool)(arg1)->Iconized();
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 {
27500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27501 }
27502 return resultobj;
27503 fail:
27504 return NULL;
27505 }
27506
27507
27508 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 PyObject *obj;
27510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27511 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27512 return SWIG_Py_Void();
27513 }
27514
27515 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27516 return SWIG_Python_InitShadowInstance(args);
27517 }
27518
27519 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27520 PyObject *resultobj = 0;
27521 int arg1 = (int) 0 ;
27522 wxMaximizeEvent *result = 0 ;
27523 int val1 ;
27524 int ecode1 = 0 ;
27525 PyObject * obj0 = 0 ;
27526 char * kwnames[] = {
27527 (char *) "id", NULL
27528 };
27529
27530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27531 if (obj0) {
27532 ecode1 = SWIG_AsVal_int(obj0, &val1);
27533 if (!SWIG_IsOK(ecode1)) {
27534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27535 }
27536 arg1 = static_cast< int >(val1);
27537 }
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27552 PyObject *obj;
27553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27554 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27555 return SWIG_Py_Void();
27556 }
27557
27558 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27559 return SWIG_Python_InitShadowInstance(args);
27560 }
27561
27562 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27563 PyObject *resultobj = 0;
27564 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27565 wxPoint result;
27566 void *argp1 = 0 ;
27567 int res1 = 0 ;
27568 PyObject *swig_obj[1] ;
27569
27570 if (!args) SWIG_fail;
27571 swig_obj[0] = args;
27572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27573 if (!SWIG_IsOK(res1)) {
27574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27575 }
27576 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (arg1)->GetPosition();
27580 wxPyEndAllowThreads(__tstate);
27581 if (PyErr_Occurred()) SWIG_fail;
27582 }
27583 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27584 return resultobj;
27585 fail:
27586 return NULL;
27587 }
27588
27589
27590 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27591 PyObject *resultobj = 0;
27592 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27593 int result;
27594 void *argp1 = 0 ;
27595 int res1 = 0 ;
27596 PyObject *swig_obj[1] ;
27597
27598 if (!args) SWIG_fail;
27599 swig_obj[0] = args;
27600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27601 if (!SWIG_IsOK(res1)) {
27602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27603 }
27604 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27605 {
27606 PyThreadState* __tstate = wxPyBeginAllowThreads();
27607 result = (int)(arg1)->GetNumberOfFiles();
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 resultobj = SWIG_From_int(static_cast< int >(result));
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27619 PyObject *resultobj = 0;
27620 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27621 PyObject *result = 0 ;
27622 void *argp1 = 0 ;
27623 int res1 = 0 ;
27624 PyObject *swig_obj[1] ;
27625
27626 if (!args) SWIG_fail;
27627 swig_obj[0] = args;
27628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27631 }
27632 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 resultobj = result;
27640 return resultobj;
27641 fail:
27642 return NULL;
27643 }
27644
27645
27646 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27647 PyObject *obj;
27648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27649 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27650 return SWIG_Py_Void();
27651 }
27652
27653 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27654 PyObject *resultobj = 0;
27655 int arg1 = (int) 0 ;
27656 wxUpdateUIEvent *result = 0 ;
27657 int val1 ;
27658 int ecode1 = 0 ;
27659 PyObject * obj0 = 0 ;
27660 char * kwnames[] = {
27661 (char *) "commandId", NULL
27662 };
27663
27664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27665 if (obj0) {
27666 ecode1 = SWIG_AsVal_int(obj0, &val1);
27667 if (!SWIG_IsOK(ecode1)) {
27668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27669 }
27670 arg1 = static_cast< int >(val1);
27671 }
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27675 wxPyEndAllowThreads(__tstate);
27676 if (PyErr_Occurred()) SWIG_fail;
27677 }
27678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27686 PyObject *resultobj = 0;
27687 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27688 bool result;
27689 void *argp1 = 0 ;
27690 int res1 = 0 ;
27691 PyObject *swig_obj[1] ;
27692
27693 if (!args) SWIG_fail;
27694 swig_obj[0] = args;
27695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27696 if (!SWIG_IsOK(res1)) {
27697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27698 }
27699 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27700 {
27701 PyThreadState* __tstate = wxPyBeginAllowThreads();
27702 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27703 wxPyEndAllowThreads(__tstate);
27704 if (PyErr_Occurred()) SWIG_fail;
27705 }
27706 {
27707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27708 }
27709 return resultobj;
27710 fail:
27711 return NULL;
27712 }
27713
27714
27715 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27716 PyObject *resultobj = 0;
27717 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27718 bool result;
27719 void *argp1 = 0 ;
27720 int res1 = 0 ;
27721 PyObject *swig_obj[1] ;
27722
27723 if (!args) SWIG_fail;
27724 swig_obj[0] = args;
27725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27726 if (!SWIG_IsOK(res1)) {
27727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27728 }
27729 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 {
27737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27738 }
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27748 bool result;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 PyObject *swig_obj[1] ;
27752
27753 if (!args) SWIG_fail;
27754 swig_obj[0] = args;
27755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27758 }
27759 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 {
27767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27768 }
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27776 PyObject *resultobj = 0;
27777 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27778 wxString result;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 PyObject *swig_obj[1] ;
27782
27783 if (!args) SWIG_fail;
27784 swig_obj[0] = args;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27788 }
27789 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27793 wxPyEndAllowThreads(__tstate);
27794 if (PyErr_Occurred()) SWIG_fail;
27795 }
27796 {
27797 #if wxUSE_UNICODE
27798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27799 #else
27800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27801 #endif
27802 }
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27812 bool result;
27813 void *argp1 = 0 ;
27814 int res1 = 0 ;
27815 PyObject *swig_obj[1] ;
27816
27817 if (!args) SWIG_fail;
27818 swig_obj[0] = args;
27819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27820 if (!SWIG_IsOK(res1)) {
27821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27822 }
27823 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27827 wxPyEndAllowThreads(__tstate);
27828 if (PyErr_Occurred()) SWIG_fail;
27829 }
27830 {
27831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27832 }
27833 return resultobj;
27834 fail:
27835 return NULL;
27836 }
27837
27838
27839 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27840 PyObject *resultobj = 0;
27841 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27842 bool result;
27843 void *argp1 = 0 ;
27844 int res1 = 0 ;
27845 PyObject *swig_obj[1] ;
27846
27847 if (!args) SWIG_fail;
27848 swig_obj[0] = args;
27849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27850 if (!SWIG_IsOK(res1)) {
27851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27852 }
27853 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27854 {
27855 PyThreadState* __tstate = wxPyBeginAllowThreads();
27856 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 {
27861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27870 PyObject *resultobj = 0;
27871 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27872 bool result;
27873 void *argp1 = 0 ;
27874 int res1 = 0 ;
27875 PyObject *swig_obj[1] ;
27876
27877 if (!args) SWIG_fail;
27878 swig_obj[0] = args;
27879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27880 if (!SWIG_IsOK(res1)) {
27881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27882 }
27883 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 {
27891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27892 }
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27900 PyObject *resultobj = 0;
27901 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27902 bool result;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 PyObject *swig_obj[1] ;
27906
27907 if (!args) SWIG_fail;
27908 swig_obj[0] = args;
27909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27910 if (!SWIG_IsOK(res1)) {
27911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27912 }
27913 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 {
27921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27922 }
27923 return resultobj;
27924 fail:
27925 return NULL;
27926 }
27927
27928
27929 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27930 PyObject *resultobj = 0;
27931 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27932 bool arg2 ;
27933 void *argp1 = 0 ;
27934 int res1 = 0 ;
27935 bool val2 ;
27936 int ecode2 = 0 ;
27937 PyObject * obj0 = 0 ;
27938 PyObject * obj1 = 0 ;
27939 char * kwnames[] = {
27940 (char *) "self",(char *) "check", NULL
27941 };
27942
27943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27945 if (!SWIG_IsOK(res1)) {
27946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27947 }
27948 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27950 if (!SWIG_IsOK(ecode2)) {
27951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27952 }
27953 arg2 = static_cast< bool >(val2);
27954 {
27955 PyThreadState* __tstate = wxPyBeginAllowThreads();
27956 (arg1)->Check(arg2);
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 resultobj = SWIG_Py_Void();
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj = 0;
27969 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27970 bool arg2 ;
27971 void *argp1 = 0 ;
27972 int res1 = 0 ;
27973 bool val2 ;
27974 int ecode2 = 0 ;
27975 PyObject * obj0 = 0 ;
27976 PyObject * obj1 = 0 ;
27977 char * kwnames[] = {
27978 (char *) "self",(char *) "enable", NULL
27979 };
27980
27981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27983 if (!SWIG_IsOK(res1)) {
27984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27985 }
27986 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27988 if (!SWIG_IsOK(ecode2)) {
27989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27990 }
27991 arg2 = static_cast< bool >(val2);
27992 {
27993 PyThreadState* __tstate = wxPyBeginAllowThreads();
27994 (arg1)->Enable(arg2);
27995 wxPyEndAllowThreads(__tstate);
27996 if (PyErr_Occurred()) SWIG_fail;
27997 }
27998 resultobj = SWIG_Py_Void();
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(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 *) "show", NULL
28017 };
28018
28019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",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_Show" "', 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_Show" "', expected argument " "2"" of type '" "bool""'");
28028 }
28029 arg2 = static_cast< bool >(val2);
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 (arg1)->Show(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_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj = 0;
28045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28046 wxString *arg2 = 0 ;
28047 void *argp1 = 0 ;
28048 int res1 = 0 ;
28049 bool temp2 = false ;
28050 PyObject * obj0 = 0 ;
28051 PyObject * obj1 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "self",(char *) "text", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28058 if (!SWIG_IsOK(res1)) {
28059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28060 }
28061 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28062 {
28063 arg2 = wxString_in_helper(obj1);
28064 if (arg2 == NULL) SWIG_fail;
28065 temp2 = true;
28066 }
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 (arg1)->SetText((wxString const &)*arg2);
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 resultobj = SWIG_Py_Void();
28074 {
28075 if (temp2)
28076 delete arg2;
28077 }
28078 return resultobj;
28079 fail:
28080 {
28081 if (temp2)
28082 delete arg2;
28083 }
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj = 0;
28090 long arg1 ;
28091 long val1 ;
28092 int ecode1 = 0 ;
28093 PyObject * obj0 = 0 ;
28094 char * kwnames[] = {
28095 (char *) "updateInterval", NULL
28096 };
28097
28098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28099 ecode1 = SWIG_AsVal_long(obj0, &val1);
28100 if (!SWIG_IsOK(ecode1)) {
28101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28102 }
28103 arg1 = static_cast< long >(val1);
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 wxUpdateUIEvent::SetUpdateInterval(arg1);
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 resultobj = SWIG_Py_Void();
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28118 PyObject *resultobj = 0;
28119 long result;
28120
28121 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_From_long(static_cast< long >(result));
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj = 0;
28137 wxWindow *arg1 = (wxWindow *) 0 ;
28138 bool result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 PyObject * obj0 = 0 ;
28142 char * kwnames[] = {
28143 (char *) "win", NULL
28144 };
28145
28146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28148 if (!SWIG_IsOK(res1)) {
28149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28150 }
28151 arg1 = reinterpret_cast< wxWindow * >(argp1);
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28155 wxPyEndAllowThreads(__tstate);
28156 if (PyErr_Occurred()) SWIG_fail;
28157 }
28158 {
28159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28160 }
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169
28170 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 wxUpdateUIEvent::ResetUpdateTime();
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 resultobj = SWIG_Py_Void();
28178 return resultobj;
28179 fail:
28180 return NULL;
28181 }
28182
28183
28184 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28185 PyObject *resultobj = 0;
28186 wxUpdateUIMode arg1 ;
28187 int val1 ;
28188 int ecode1 = 0 ;
28189 PyObject * obj0 = 0 ;
28190 char * kwnames[] = {
28191 (char *) "mode", NULL
28192 };
28193
28194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28195 ecode1 = SWIG_AsVal_int(obj0, &val1);
28196 if (!SWIG_IsOK(ecode1)) {
28197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28198 }
28199 arg1 = static_cast< wxUpdateUIMode >(val1);
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 wxUpdateUIEvent::SetMode(arg1);
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 resultobj = SWIG_Py_Void();
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28214 PyObject *resultobj = 0;
28215 wxUpdateUIMode result;
28216
28217 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_From_int(static_cast< int >(result));
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 PyObject *obj;
28233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28234 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28235 return SWIG_Py_Void();
28236 }
28237
28238 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28239 return SWIG_Python_InitShadowInstance(args);
28240 }
28241
28242 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 wxSysColourChangedEvent *result = 0 ;
28245
28246 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 PyObject *obj;
28262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28263 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28264 return SWIG_Py_Void();
28265 }
28266
28267 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28268 return SWIG_Python_InitShadowInstance(args);
28269 }
28270
28271 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj = 0;
28273 int arg1 = (int) 0 ;
28274 wxWindow *arg2 = (wxWindow *) NULL ;
28275 wxMouseCaptureChangedEvent *result = 0 ;
28276 int val1 ;
28277 int ecode1 = 0 ;
28278 void *argp2 = 0 ;
28279 int res2 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 PyObject * obj1 = 0 ;
28282 char * kwnames[] = {
28283 (char *) "winid",(char *) "gainedCapture", NULL
28284 };
28285
28286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28287 if (obj0) {
28288 ecode1 = SWIG_AsVal_int(obj0, &val1);
28289 if (!SWIG_IsOK(ecode1)) {
28290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28291 }
28292 arg1 = static_cast< int >(val1);
28293 }
28294 if (obj1) {
28295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28296 if (!SWIG_IsOK(res2)) {
28297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28298 }
28299 arg2 = reinterpret_cast< wxWindow * >(argp2);
28300 }
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 PyObject *resultobj = 0;
28316 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28317 wxWindow *result = 0 ;
28318 void *argp1 = 0 ;
28319 int res1 = 0 ;
28320 PyObject *swig_obj[1] ;
28321
28322 if (!args) SWIG_fail;
28323 swig_obj[0] = args;
28324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28325 if (!SWIG_IsOK(res1)) {
28326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28327 }
28328 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = wxPyMake_wxObject(result, (bool)0);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *obj;
28346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28347 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28348 return SWIG_Py_Void();
28349 }
28350
28351 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28352 return SWIG_Python_InitShadowInstance(args);
28353 }
28354
28355 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj = 0;
28357 int arg1 = (int) 0 ;
28358 wxMouseCaptureLostEvent *result = 0 ;
28359 int val1 ;
28360 int ecode1 = 0 ;
28361 PyObject * obj0 = 0 ;
28362 char * kwnames[] = {
28363 (char *) "winid", NULL
28364 };
28365
28366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28367 if (obj0) {
28368 ecode1 = SWIG_AsVal_int(obj0, &val1);
28369 if (!SWIG_IsOK(ecode1)) {
28370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28371 }
28372 arg1 = static_cast< int >(val1);
28373 }
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 PyObject *obj;
28389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28390 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28391 return SWIG_Py_Void();
28392 }
28393
28394 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28395 return SWIG_Python_InitShadowInstance(args);
28396 }
28397
28398 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 PyObject *resultobj = 0;
28400 wxDisplayChangedEvent *result = 0 ;
28401
28402 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28410 return resultobj;
28411 fail:
28412 return NULL;
28413 }
28414
28415
28416 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 PyObject *obj;
28418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28419 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28420 return SWIG_Py_Void();
28421 }
28422
28423 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28424 return SWIG_Python_InitShadowInstance(args);
28425 }
28426
28427 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28428 PyObject *resultobj = 0;
28429 int arg1 = (int) 0 ;
28430 wxPaletteChangedEvent *result = 0 ;
28431 int val1 ;
28432 int ecode1 = 0 ;
28433 PyObject * obj0 = 0 ;
28434 char * kwnames[] = {
28435 (char *) "id", NULL
28436 };
28437
28438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28439 if (obj0) {
28440 ecode1 = SWIG_AsVal_int(obj0, &val1);
28441 if (!SWIG_IsOK(ecode1)) {
28442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28443 }
28444 arg1 = static_cast< int >(val1);
28445 }
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28449 wxPyEndAllowThreads(__tstate);
28450 if (PyErr_Occurred()) SWIG_fail;
28451 }
28452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28453 return resultobj;
28454 fail:
28455 return NULL;
28456 }
28457
28458
28459 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28460 PyObject *resultobj = 0;
28461 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28462 wxWindow *arg2 = (wxWindow *) 0 ;
28463 void *argp1 = 0 ;
28464 int res1 = 0 ;
28465 void *argp2 = 0 ;
28466 int res2 = 0 ;
28467 PyObject * obj0 = 0 ;
28468 PyObject * obj1 = 0 ;
28469 char * kwnames[] = {
28470 (char *) "self",(char *) "win", NULL
28471 };
28472
28473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28475 if (!SWIG_IsOK(res1)) {
28476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28477 }
28478 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28480 if (!SWIG_IsOK(res2)) {
28481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28482 }
28483 arg2 = reinterpret_cast< wxWindow * >(argp2);
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 (arg1)->SetChangedWindow(arg2);
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 resultobj = SWIG_Py_Void();
28491 return resultobj;
28492 fail:
28493 return NULL;
28494 }
28495
28496
28497 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28498 PyObject *resultobj = 0;
28499 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28500 wxWindow *result = 0 ;
28501 void *argp1 = 0 ;
28502 int res1 = 0 ;
28503 PyObject *swig_obj[1] ;
28504
28505 if (!args) SWIG_fail;
28506 swig_obj[0] = args;
28507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28508 if (!SWIG_IsOK(res1)) {
28509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28510 }
28511 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28512 {
28513 PyThreadState* __tstate = wxPyBeginAllowThreads();
28514 result = (wxWindow *)(arg1)->GetChangedWindow();
28515 wxPyEndAllowThreads(__tstate);
28516 if (PyErr_Occurred()) SWIG_fail;
28517 }
28518 {
28519 resultobj = wxPyMake_wxObject(result, (bool)0);
28520 }
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 PyObject *obj;
28529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28530 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28531 return SWIG_Py_Void();
28532 }
28533
28534 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28535 return SWIG_Python_InitShadowInstance(args);
28536 }
28537
28538 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28539 PyObject *resultobj = 0;
28540 int arg1 = (int) 0 ;
28541 wxQueryNewPaletteEvent *result = 0 ;
28542 int val1 ;
28543 int ecode1 = 0 ;
28544 PyObject * obj0 = 0 ;
28545 char * kwnames[] = {
28546 (char *) "winid", NULL
28547 };
28548
28549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28550 if (obj0) {
28551 ecode1 = SWIG_AsVal_int(obj0, &val1);
28552 if (!SWIG_IsOK(ecode1)) {
28553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28554 }
28555 arg1 = static_cast< int >(val1);
28556 }
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28571 PyObject *resultobj = 0;
28572 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28573 bool arg2 ;
28574 void *argp1 = 0 ;
28575 int res1 = 0 ;
28576 bool val2 ;
28577 int ecode2 = 0 ;
28578 PyObject * obj0 = 0 ;
28579 PyObject * obj1 = 0 ;
28580 char * kwnames[] = {
28581 (char *) "self",(char *) "realized", NULL
28582 };
28583
28584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28586 if (!SWIG_IsOK(res1)) {
28587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28588 }
28589 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28591 if (!SWIG_IsOK(ecode2)) {
28592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28593 }
28594 arg2 = static_cast< bool >(val2);
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 (arg1)->SetPaletteRealized(arg2);
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 resultobj = SWIG_Py_Void();
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28609 PyObject *resultobj = 0;
28610 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28611 bool result;
28612 void *argp1 = 0 ;
28613 int res1 = 0 ;
28614 PyObject *swig_obj[1] ;
28615
28616 if (!args) SWIG_fail;
28617 swig_obj[0] = args;
28618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28619 if (!SWIG_IsOK(res1)) {
28620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28621 }
28622 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 {
28630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28631 }
28632 return resultobj;
28633 fail:
28634 return NULL;
28635 }
28636
28637
28638 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28639 PyObject *obj;
28640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28641 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28642 return SWIG_Py_Void();
28643 }
28644
28645 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28646 return SWIG_Python_InitShadowInstance(args);
28647 }
28648
28649 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 PyObject *resultobj = 0;
28651 wxNavigationKeyEvent *result = 0 ;
28652
28653 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28654 {
28655 PyThreadState* __tstate = wxPyBeginAllowThreads();
28656 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *resultobj = 0;
28669 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28670 bool result;
28671 void *argp1 = 0 ;
28672 int res1 = 0 ;
28673 PyObject *swig_obj[1] ;
28674
28675 if (!args) SWIG_fail;
28676 swig_obj[0] = args;
28677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28680 }
28681 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28682 {
28683 PyThreadState* __tstate = wxPyBeginAllowThreads();
28684 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 {
28689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28690 }
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj = 0;
28699 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28700 bool arg2 ;
28701 void *argp1 = 0 ;
28702 int res1 = 0 ;
28703 bool val2 ;
28704 int ecode2 = 0 ;
28705 PyObject * obj0 = 0 ;
28706 PyObject * obj1 = 0 ;
28707 char * kwnames[] = {
28708 (char *) "self",(char *) "forward", NULL
28709 };
28710
28711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28713 if (!SWIG_IsOK(res1)) {
28714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28715 }
28716 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28717 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28718 if (!SWIG_IsOK(ecode2)) {
28719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28720 }
28721 arg2 = static_cast< bool >(val2);
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 (arg1)->SetDirection(arg2);
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_Py_Void();
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28736 PyObject *resultobj = 0;
28737 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28738 bool result;
28739 void *argp1 = 0 ;
28740 int res1 = 0 ;
28741 PyObject *swig_obj[1] ;
28742
28743 if (!args) SWIG_fail;
28744 swig_obj[0] = args;
28745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28746 if (!SWIG_IsOK(res1)) {
28747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28748 }
28749 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 {
28757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28758 }
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj = 0;
28767 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28768 bool arg2 ;
28769 void *argp1 = 0 ;
28770 int res1 = 0 ;
28771 bool val2 ;
28772 int ecode2 = 0 ;
28773 PyObject * obj0 = 0 ;
28774 PyObject * obj1 = 0 ;
28775 char * kwnames[] = {
28776 (char *) "self",(char *) "ischange", NULL
28777 };
28778
28779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28781 if (!SWIG_IsOK(res1)) {
28782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28783 }
28784 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28785 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28786 if (!SWIG_IsOK(ecode2)) {
28787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28788 }
28789 arg2 = static_cast< bool >(val2);
28790 {
28791 PyThreadState* __tstate = wxPyBeginAllowThreads();
28792 (arg1)->SetWindowChange(arg2);
28793 wxPyEndAllowThreads(__tstate);
28794 if (PyErr_Occurred()) SWIG_fail;
28795 }
28796 resultobj = SWIG_Py_Void();
28797 return resultobj;
28798 fail:
28799 return NULL;
28800 }
28801
28802
28803 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28804 PyObject *resultobj = 0;
28805 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28806 bool result;
28807 void *argp1 = 0 ;
28808 int res1 = 0 ;
28809 PyObject *swig_obj[1] ;
28810
28811 if (!args) SWIG_fail;
28812 swig_obj[0] = args;
28813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28814 if (!SWIG_IsOK(res1)) {
28815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28816 }
28817 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 {
28825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28826 }
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28834 PyObject *resultobj = 0;
28835 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28836 bool arg2 ;
28837 void *argp1 = 0 ;
28838 int res1 = 0 ;
28839 bool val2 ;
28840 int ecode2 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 PyObject * obj1 = 0 ;
28843 char * kwnames[] = {
28844 (char *) "self",(char *) "bIs", NULL
28845 };
28846
28847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28849 if (!SWIG_IsOK(res1)) {
28850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28851 }
28852 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28854 if (!SWIG_IsOK(ecode2)) {
28855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28856 }
28857 arg2 = static_cast< bool >(val2);
28858 {
28859 PyThreadState* __tstate = wxPyBeginAllowThreads();
28860 (arg1)->SetFromTab(arg2);
28861 wxPyEndAllowThreads(__tstate);
28862 if (PyErr_Occurred()) SWIG_fail;
28863 }
28864 resultobj = SWIG_Py_Void();
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj = 0;
28873 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28874 long arg2 ;
28875 void *argp1 = 0 ;
28876 int res1 = 0 ;
28877 long val2 ;
28878 int ecode2 = 0 ;
28879 PyObject * obj0 = 0 ;
28880 PyObject * obj1 = 0 ;
28881 char * kwnames[] = {
28882 (char *) "self",(char *) "flags", NULL
28883 };
28884
28885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28887 if (!SWIG_IsOK(res1)) {
28888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28889 }
28890 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28891 ecode2 = SWIG_AsVal_long(obj1, &val2);
28892 if (!SWIG_IsOK(ecode2)) {
28893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28894 }
28895 arg2 = static_cast< long >(val2);
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 (arg1)->SetFlags(arg2);
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_Py_Void();
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28910 PyObject *resultobj = 0;
28911 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28912 wxWindow *result = 0 ;
28913 void *argp1 = 0 ;
28914 int res1 = 0 ;
28915 PyObject *swig_obj[1] ;
28916
28917 if (!args) SWIG_fail;
28918 swig_obj[0] = args;
28919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28920 if (!SWIG_IsOK(res1)) {
28921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28922 }
28923 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 {
28931 resultobj = wxPyMake_wxObject(result, (bool)0);
28932 }
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28940 PyObject *resultobj = 0;
28941 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28942 wxWindow *arg2 = (wxWindow *) 0 ;
28943 void *argp1 = 0 ;
28944 int res1 = 0 ;
28945 void *argp2 = 0 ;
28946 int res2 = 0 ;
28947 PyObject * obj0 = 0 ;
28948 PyObject * obj1 = 0 ;
28949 char * kwnames[] = {
28950 (char *) "self",(char *) "win", NULL
28951 };
28952
28953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28955 if (!SWIG_IsOK(res1)) {
28956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28957 }
28958 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28960 if (!SWIG_IsOK(res2)) {
28961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28962 }
28963 arg2 = reinterpret_cast< wxWindow * >(argp2);
28964 {
28965 PyThreadState* __tstate = wxPyBeginAllowThreads();
28966 (arg1)->SetCurrentFocus(arg2);
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 resultobj = SWIG_Py_Void();
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28978 PyObject *obj;
28979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28980 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28981 return SWIG_Py_Void();
28982 }
28983
28984 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28985 return SWIG_Python_InitShadowInstance(args);
28986 }
28987
28988 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj = 0;
28990 wxWindow *arg1 = (wxWindow *) NULL ;
28991 wxWindowCreateEvent *result = 0 ;
28992 void *argp1 = 0 ;
28993 int res1 = 0 ;
28994 PyObject * obj0 = 0 ;
28995 char * kwnames[] = {
28996 (char *) "win", NULL
28997 };
28998
28999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29000 if (obj0) {
29001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29002 if (!SWIG_IsOK(res1)) {
29003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29004 }
29005 arg1 = reinterpret_cast< wxWindow * >(argp1);
29006 }
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29021 PyObject *resultobj = 0;
29022 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29023 wxWindow *result = 0 ;
29024 void *argp1 = 0 ;
29025 int res1 = 0 ;
29026 PyObject *swig_obj[1] ;
29027
29028 if (!args) SWIG_fail;
29029 swig_obj[0] = args;
29030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29031 if (!SWIG_IsOK(res1)) {
29032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29033 }
29034 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29035 {
29036 PyThreadState* __tstate = wxPyBeginAllowThreads();
29037 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 {
29042 resultobj = wxPyMake_wxObject(result, (bool)0);
29043 }
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 PyObject *obj;
29052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29053 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29054 return SWIG_Py_Void();
29055 }
29056
29057 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29058 return SWIG_Python_InitShadowInstance(args);
29059 }
29060
29061 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj = 0;
29063 wxWindow *arg1 = (wxWindow *) NULL ;
29064 wxWindowDestroyEvent *result = 0 ;
29065 void *argp1 = 0 ;
29066 int res1 = 0 ;
29067 PyObject * obj0 = 0 ;
29068 char * kwnames[] = {
29069 (char *) "win", NULL
29070 };
29071
29072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29073 if (obj0) {
29074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29075 if (!SWIG_IsOK(res1)) {
29076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29077 }
29078 arg1 = reinterpret_cast< wxWindow * >(argp1);
29079 }
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29087 return resultobj;
29088 fail:
29089 return NULL;
29090 }
29091
29092
29093 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29094 PyObject *resultobj = 0;
29095 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29096 wxWindow *result = 0 ;
29097 void *argp1 = 0 ;
29098 int res1 = 0 ;
29099 PyObject *swig_obj[1] ;
29100
29101 if (!args) SWIG_fail;
29102 swig_obj[0] = args;
29103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29106 }
29107 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 {
29115 resultobj = wxPyMake_wxObject(result, (bool)0);
29116 }
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 PyObject *obj;
29125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29126 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29127 return SWIG_Py_Void();
29128 }
29129
29130 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131 return SWIG_Python_InitShadowInstance(args);
29132 }
29133
29134 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29135 PyObject *resultobj = 0;
29136 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29137 int arg2 = (int) 0 ;
29138 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29139 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29140 wxContextMenuEvent *result = 0 ;
29141 int val1 ;
29142 int ecode1 = 0 ;
29143 int val2 ;
29144 int ecode2 = 0 ;
29145 wxPoint temp3 ;
29146 PyObject * obj0 = 0 ;
29147 PyObject * obj1 = 0 ;
29148 PyObject * obj2 = 0 ;
29149 char * kwnames[] = {
29150 (char *) "type",(char *) "winid",(char *) "pt", NULL
29151 };
29152
29153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29154 if (obj0) {
29155 ecode1 = SWIG_AsVal_int(obj0, &val1);
29156 if (!SWIG_IsOK(ecode1)) {
29157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29158 }
29159 arg1 = static_cast< wxEventType >(val1);
29160 }
29161 if (obj1) {
29162 ecode2 = SWIG_AsVal_int(obj1, &val2);
29163 if (!SWIG_IsOK(ecode2)) {
29164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29165 }
29166 arg2 = static_cast< int >(val2);
29167 }
29168 if (obj2) {
29169 {
29170 arg3 = &temp3;
29171 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29172 }
29173 }
29174 {
29175 PyThreadState* __tstate = wxPyBeginAllowThreads();
29176 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29177 wxPyEndAllowThreads(__tstate);
29178 if (PyErr_Occurred()) SWIG_fail;
29179 }
29180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29181 return resultobj;
29182 fail:
29183 return NULL;
29184 }
29185
29186
29187 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29188 PyObject *resultobj = 0;
29189 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29190 wxPoint *result = 0 ;
29191 void *argp1 = 0 ;
29192 int res1 = 0 ;
29193 PyObject *swig_obj[1] ;
29194
29195 if (!args) SWIG_fail;
29196 swig_obj[0] = args;
29197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29198 if (!SWIG_IsOK(res1)) {
29199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29200 }
29201 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 {
29205 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29206 result = (wxPoint *) &_result_ref;
29207 }
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29219 PyObject *resultobj = 0;
29220 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29221 wxPoint *arg2 = 0 ;
29222 void *argp1 = 0 ;
29223 int res1 = 0 ;
29224 wxPoint temp2 ;
29225 PyObject * obj0 = 0 ;
29226 PyObject * obj1 = 0 ;
29227 char * kwnames[] = {
29228 (char *) "self",(char *) "pos", NULL
29229 };
29230
29231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29235 }
29236 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29237 {
29238 arg2 = &temp2;
29239 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29240 }
29241 {
29242 PyThreadState* __tstate = wxPyBeginAllowThreads();
29243 (arg1)->SetPosition((wxPoint const &)*arg2);
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 resultobj = SWIG_Py_Void();
29248 return resultobj;
29249 fail:
29250 return NULL;
29251 }
29252
29253
29254 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29255 PyObject *obj;
29256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29257 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29258 return SWIG_Py_Void();
29259 }
29260
29261 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29262 return SWIG_Python_InitShadowInstance(args);
29263 }
29264
29265 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29266 PyObject *resultobj = 0;
29267 wxIdleEvent *result = 0 ;
29268
29269 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 result = (wxIdleEvent *)new wxIdleEvent();
29273 wxPyEndAllowThreads(__tstate);
29274 if (PyErr_Occurred()) SWIG_fail;
29275 }
29276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29277 return resultobj;
29278 fail:
29279 return NULL;
29280 }
29281
29282
29283 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29284 PyObject *resultobj = 0;
29285 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29286 bool arg2 = (bool) true ;
29287 void *argp1 = 0 ;
29288 int res1 = 0 ;
29289 bool val2 ;
29290 int ecode2 = 0 ;
29291 PyObject * obj0 = 0 ;
29292 PyObject * obj1 = 0 ;
29293 char * kwnames[] = {
29294 (char *) "self",(char *) "needMore", NULL
29295 };
29296
29297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29299 if (!SWIG_IsOK(res1)) {
29300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29301 }
29302 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29303 if (obj1) {
29304 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29305 if (!SWIG_IsOK(ecode2)) {
29306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29307 }
29308 arg2 = static_cast< bool >(val2);
29309 }
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 (arg1)->RequestMore(arg2);
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 resultobj = SWIG_Py_Void();
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29324 PyObject *resultobj = 0;
29325 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29326 bool result;
29327 void *argp1 = 0 ;
29328 int res1 = 0 ;
29329 PyObject *swig_obj[1] ;
29330
29331 if (!args) SWIG_fail;
29332 swig_obj[0] = args;
29333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29334 if (!SWIG_IsOK(res1)) {
29335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29336 }
29337 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 {
29345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29346 }
29347 return resultobj;
29348 fail:
29349 return NULL;
29350 }
29351
29352
29353 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29354 PyObject *resultobj = 0;
29355 wxIdleMode arg1 ;
29356 int val1 ;
29357 int ecode1 = 0 ;
29358 PyObject * obj0 = 0 ;
29359 char * kwnames[] = {
29360 (char *) "mode", NULL
29361 };
29362
29363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29364 ecode1 = SWIG_AsVal_int(obj0, &val1);
29365 if (!SWIG_IsOK(ecode1)) {
29366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29367 }
29368 arg1 = static_cast< wxIdleMode >(val1);
29369 {
29370 PyThreadState* __tstate = wxPyBeginAllowThreads();
29371 wxIdleEvent::SetMode(arg1);
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 resultobj = SWIG_Py_Void();
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29383 PyObject *resultobj = 0;
29384 wxIdleMode result;
29385
29386 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 result = (wxIdleMode)wxIdleEvent::GetMode();
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_From_int(static_cast< int >(result));
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29401 PyObject *resultobj = 0;
29402 wxWindow *arg1 = (wxWindow *) 0 ;
29403 bool result;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 PyObject * obj0 = 0 ;
29407 char * kwnames[] = {
29408 (char *) "win", NULL
29409 };
29410
29411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29413 if (!SWIG_IsOK(res1)) {
29414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29415 }
29416 arg1 = reinterpret_cast< wxWindow * >(argp1);
29417 {
29418 PyThreadState* __tstate = wxPyBeginAllowThreads();
29419 result = (bool)wxIdleEvent::CanSend(arg1);
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 {
29424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29425 }
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 PyObject *obj;
29434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29435 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29436 return SWIG_Py_Void();
29437 }
29438
29439 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29440 return SWIG_Python_InitShadowInstance(args);
29441 }
29442
29443 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29444 PyObject *resultobj = 0;
29445 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29446 int arg2 = (int) 0 ;
29447 wxClipboardTextEvent *result = 0 ;
29448 int val1 ;
29449 int ecode1 = 0 ;
29450 int val2 ;
29451 int ecode2 = 0 ;
29452 PyObject * obj0 = 0 ;
29453 PyObject * obj1 = 0 ;
29454 char * kwnames[] = {
29455 (char *) "type",(char *) "winid", NULL
29456 };
29457
29458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29459 if (obj0) {
29460 ecode1 = SWIG_AsVal_int(obj0, &val1);
29461 if (!SWIG_IsOK(ecode1)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29463 }
29464 arg1 = static_cast< wxEventType >(val1);
29465 }
29466 if (obj1) {
29467 ecode2 = SWIG_AsVal_int(obj1, &val2);
29468 if (!SWIG_IsOK(ecode2)) {
29469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29470 }
29471 arg2 = static_cast< int >(val2);
29472 }
29473 {
29474 PyThreadState* __tstate = wxPyBeginAllowThreads();
29475 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29476 wxPyEndAllowThreads(__tstate);
29477 if (PyErr_Occurred()) SWIG_fail;
29478 }
29479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29480 return resultobj;
29481 fail:
29482 return NULL;
29483 }
29484
29485
29486 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29487 PyObject *obj;
29488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29489 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29490 return SWIG_Py_Void();
29491 }
29492
29493 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29494 return SWIG_Python_InitShadowInstance(args);
29495 }
29496
29497 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29498 PyObject *resultobj = 0;
29499 int arg1 = (int) 0 ;
29500 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29501 wxPyEvent *result = 0 ;
29502 int val1 ;
29503 int ecode1 = 0 ;
29504 int val2 ;
29505 int ecode2 = 0 ;
29506 PyObject * obj0 = 0 ;
29507 PyObject * obj1 = 0 ;
29508 char * kwnames[] = {
29509 (char *) "winid",(char *) "eventType", NULL
29510 };
29511
29512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29513 if (obj0) {
29514 ecode1 = SWIG_AsVal_int(obj0, &val1);
29515 if (!SWIG_IsOK(ecode1)) {
29516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29517 }
29518 arg1 = static_cast< int >(val1);
29519 }
29520 if (obj1) {
29521 ecode2 = SWIG_AsVal_int(obj1, &val2);
29522 if (!SWIG_IsOK(ecode2)) {
29523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29524 }
29525 arg2 = static_cast< wxEventType >(val2);
29526 }
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29534 return resultobj;
29535 fail:
29536 return NULL;
29537 }
29538
29539
29540 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29541 PyObject *resultobj = 0;
29542 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29543 void *argp1 = 0 ;
29544 int res1 = 0 ;
29545 PyObject *swig_obj[1] ;
29546
29547 if (!args) SWIG_fail;
29548 swig_obj[0] = args;
29549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29550 if (!SWIG_IsOK(res1)) {
29551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29552 }
29553 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29554 {
29555 PyThreadState* __tstate = wxPyBeginAllowThreads();
29556 delete arg1;
29557
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 resultobj = SWIG_Py_Void();
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj = 0;
29570 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29571 PyObject *arg2 = (PyObject *) 0 ;
29572 void *argp1 = 0 ;
29573 int res1 = 0 ;
29574 PyObject * obj0 = 0 ;
29575 PyObject * obj1 = 0 ;
29576 char * kwnames[] = {
29577 (char *) "self",(char *) "self", NULL
29578 };
29579
29580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29584 }
29585 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29586 arg2 = obj1;
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 (arg1)->SetSelf(arg2);
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 resultobj = SWIG_Py_Void();
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29601 PyObject *resultobj = 0;
29602 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29603 PyObject *result = 0 ;
29604 void *argp1 = 0 ;
29605 int res1 = 0 ;
29606 PyObject *swig_obj[1] ;
29607
29608 if (!args) SWIG_fail;
29609 swig_obj[0] = args;
29610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29611 if (!SWIG_IsOK(res1)) {
29612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29613 }
29614 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 result = (PyObject *)(arg1)->GetSelf();
29618 wxPyEndAllowThreads(__tstate);
29619 if (PyErr_Occurred()) SWIG_fail;
29620 }
29621 resultobj = result;
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29629 PyObject *obj;
29630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29631 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29632 return SWIG_Py_Void();
29633 }
29634
29635 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 return SWIG_Python_InitShadowInstance(args);
29637 }
29638
29639 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29640 PyObject *resultobj = 0;
29641 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29642 int arg2 = (int) 0 ;
29643 wxPyCommandEvent *result = 0 ;
29644 int val1 ;
29645 int ecode1 = 0 ;
29646 int val2 ;
29647 int ecode2 = 0 ;
29648 PyObject * obj0 = 0 ;
29649 PyObject * obj1 = 0 ;
29650 char * kwnames[] = {
29651 (char *) "eventType",(char *) "id", NULL
29652 };
29653
29654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29655 if (obj0) {
29656 ecode1 = SWIG_AsVal_int(obj0, &val1);
29657 if (!SWIG_IsOK(ecode1)) {
29658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29659 }
29660 arg1 = static_cast< wxEventType >(val1);
29661 }
29662 if (obj1) {
29663 ecode2 = SWIG_AsVal_int(obj1, &val2);
29664 if (!SWIG_IsOK(ecode2)) {
29665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29666 }
29667 arg2 = static_cast< int >(val2);
29668 }
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29676 return resultobj;
29677 fail:
29678 return NULL;
29679 }
29680
29681
29682 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29683 PyObject *resultobj = 0;
29684 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29685 void *argp1 = 0 ;
29686 int res1 = 0 ;
29687 PyObject *swig_obj[1] ;
29688
29689 if (!args) SWIG_fail;
29690 swig_obj[0] = args;
29691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29694 }
29695 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29696 {
29697 PyThreadState* __tstate = wxPyBeginAllowThreads();
29698 delete arg1;
29699
29700 wxPyEndAllowThreads(__tstate);
29701 if (PyErr_Occurred()) SWIG_fail;
29702 }
29703 resultobj = SWIG_Py_Void();
29704 return resultobj;
29705 fail:
29706 return NULL;
29707 }
29708
29709
29710 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29711 PyObject *resultobj = 0;
29712 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29713 PyObject *arg2 = (PyObject *) 0 ;
29714 void *argp1 = 0 ;
29715 int res1 = 0 ;
29716 PyObject * obj0 = 0 ;
29717 PyObject * obj1 = 0 ;
29718 char * kwnames[] = {
29719 (char *) "self",(char *) "self", NULL
29720 };
29721
29722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29724 if (!SWIG_IsOK(res1)) {
29725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29726 }
29727 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29728 arg2 = obj1;
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 (arg1)->SetSelf(arg2);
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 resultobj = SWIG_Py_Void();
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29743 PyObject *resultobj = 0;
29744 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29745 PyObject *result = 0 ;
29746 void *argp1 = 0 ;
29747 int res1 = 0 ;
29748 PyObject *swig_obj[1] ;
29749
29750 if (!args) SWIG_fail;
29751 swig_obj[0] = args;
29752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29753 if (!SWIG_IsOK(res1)) {
29754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29755 }
29756 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29757 {
29758 PyThreadState* __tstate = wxPyBeginAllowThreads();
29759 result = (PyObject *)(arg1)->GetSelf();
29760 wxPyEndAllowThreads(__tstate);
29761 if (PyErr_Occurred()) SWIG_fail;
29762 }
29763 resultobj = result;
29764 return resultobj;
29765 fail:
29766 return NULL;
29767 }
29768
29769
29770 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29771 PyObject *obj;
29772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29773 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29774 return SWIG_Py_Void();
29775 }
29776
29777 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29778 return SWIG_Python_InitShadowInstance(args);
29779 }
29780
29781 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj = 0;
29783 wxWindow *arg1 = (wxWindow *) 0 ;
29784 wxDateTime *arg2 = 0 ;
29785 wxEventType arg3 ;
29786 wxDateEvent *result = 0 ;
29787 void *argp1 = 0 ;
29788 int res1 = 0 ;
29789 void *argp2 = 0 ;
29790 int res2 = 0 ;
29791 int val3 ;
29792 int ecode3 = 0 ;
29793 PyObject * obj0 = 0 ;
29794 PyObject * obj1 = 0 ;
29795 PyObject * obj2 = 0 ;
29796 char * kwnames[] = {
29797 (char *) "win",(char *) "dt",(char *) "type", NULL
29798 };
29799
29800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29802 if (!SWIG_IsOK(res1)) {
29803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29804 }
29805 arg1 = reinterpret_cast< wxWindow * >(argp1);
29806 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29807 if (!SWIG_IsOK(res2)) {
29808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29809 }
29810 if (!argp2) {
29811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29812 }
29813 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29814 ecode3 = SWIG_AsVal_int(obj2, &val3);
29815 if (!SWIG_IsOK(ecode3)) {
29816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29817 }
29818 arg3 = static_cast< wxEventType >(val3);
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29833 PyObject *resultobj = 0;
29834 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29835 wxDateTime *result = 0 ;
29836 void *argp1 = 0 ;
29837 int res1 = 0 ;
29838 PyObject *swig_obj[1] ;
29839
29840 if (!args) SWIG_fail;
29841 swig_obj[0] = args;
29842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29843 if (!SWIG_IsOK(res1)) {
29844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29845 }
29846 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29847 {
29848 PyThreadState* __tstate = wxPyBeginAllowThreads();
29849 {
29850 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29851 result = (wxDateTime *) &_result_ref;
29852 }
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj = 0;
29865 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29866 wxDateTime *arg2 = 0 ;
29867 void *argp1 = 0 ;
29868 int res1 = 0 ;
29869 void *argp2 = 0 ;
29870 int res2 = 0 ;
29871 PyObject * obj0 = 0 ;
29872 PyObject * obj1 = 0 ;
29873 char * kwnames[] = {
29874 (char *) "self",(char *) "date", NULL
29875 };
29876
29877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29879 if (!SWIG_IsOK(res1)) {
29880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29881 }
29882 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29884 if (!SWIG_IsOK(res2)) {
29885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29886 }
29887 if (!argp2) {
29888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29889 }
29890 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29891 {
29892 PyThreadState* __tstate = wxPyBeginAllowThreads();
29893 (arg1)->SetDate((wxDateTime const &)*arg2);
29894 wxPyEndAllowThreads(__tstate);
29895 if (PyErr_Occurred()) SWIG_fail;
29896 }
29897 resultobj = SWIG_Py_Void();
29898 return resultobj;
29899 fail:
29900 return NULL;
29901 }
29902
29903
29904 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29905 PyObject *obj;
29906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29907 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29908 return SWIG_Py_Void();
29909 }
29910
29911 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29912 return SWIG_Python_InitShadowInstance(args);
29913 }
29914
29915 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29916 PyObject *resultobj = 0;
29917 wxPyApp *result = 0 ;
29918
29919 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (wxPyApp *)new_wxPyApp();
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29934 PyObject *resultobj = 0;
29935 wxPyApp *arg1 = (wxPyApp *) 0 ;
29936 void *argp1 = 0 ;
29937 int res1 = 0 ;
29938 PyObject *swig_obj[1] ;
29939
29940 if (!args) SWIG_fail;
29941 swig_obj[0] = args;
29942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29943 if (!SWIG_IsOK(res1)) {
29944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29945 }
29946 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 delete arg1;
29950
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 resultobj = SWIG_Py_Void();
29955 return resultobj;
29956 fail:
29957 return NULL;
29958 }
29959
29960
29961 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29962 PyObject *resultobj = 0;
29963 wxPyApp *arg1 = (wxPyApp *) 0 ;
29964 PyObject *arg2 = (PyObject *) 0 ;
29965 PyObject *arg3 = (PyObject *) 0 ;
29966 bool arg4 ;
29967 void *argp1 = 0 ;
29968 int res1 = 0 ;
29969 bool val4 ;
29970 int ecode4 = 0 ;
29971 PyObject * obj0 = 0 ;
29972 PyObject * obj1 = 0 ;
29973 PyObject * obj2 = 0 ;
29974 PyObject * obj3 = 0 ;
29975 char * kwnames[] = {
29976 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29977 };
29978
29979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29981 if (!SWIG_IsOK(res1)) {
29982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29983 }
29984 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29985 arg2 = obj1;
29986 arg3 = obj2;
29987 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29988 if (!SWIG_IsOK(ecode4)) {
29989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29990 }
29991 arg4 = static_cast< bool >(val4);
29992 {
29993 PyThreadState* __tstate = wxPyBeginAllowThreads();
29994 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 resultobj = SWIG_Py_Void();
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30006 PyObject *resultobj = 0;
30007 wxPyApp *arg1 = (wxPyApp *) 0 ;
30008 wxString result;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 PyObject *swig_obj[1] ;
30012
30013 if (!args) SWIG_fail;
30014 swig_obj[0] = args;
30015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30016 if (!SWIG_IsOK(res1)) {
30017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30018 }
30019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = ((wxPyApp const *)arg1)->GetAppName();
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 {
30027 #if wxUSE_UNICODE
30028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30029 #else
30030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30031 #endif
30032 }
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30040 PyObject *resultobj = 0;
30041 wxPyApp *arg1 = (wxPyApp *) 0 ;
30042 wxString *arg2 = 0 ;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 bool temp2 = false ;
30046 PyObject * obj0 = 0 ;
30047 PyObject * obj1 = 0 ;
30048 char * kwnames[] = {
30049 (char *) "self",(char *) "name", NULL
30050 };
30051
30052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30056 }
30057 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30058 {
30059 arg2 = wxString_in_helper(obj1);
30060 if (arg2 == NULL) SWIG_fail;
30061 temp2 = true;
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 (arg1)->SetAppName((wxString const &)*arg2);
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_Py_Void();
30070 {
30071 if (temp2)
30072 delete arg2;
30073 }
30074 return resultobj;
30075 fail:
30076 {
30077 if (temp2)
30078 delete arg2;
30079 }
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 wxPyApp *arg1 = (wxPyApp *) 0 ;
30087 wxString result;
30088 void *argp1 = 0 ;
30089 int res1 = 0 ;
30090 PyObject *swig_obj[1] ;
30091
30092 if (!args) SWIG_fail;
30093 swig_obj[0] = args;
30094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30095 if (!SWIG_IsOK(res1)) {
30096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30097 }
30098 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 result = ((wxPyApp const *)arg1)->GetClassName();
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 #if wxUSE_UNICODE
30107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30108 #else
30109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30110 #endif
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxPyApp *arg1 = (wxPyApp *) 0 ;
30121 wxString *arg2 = 0 ;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 bool temp2 = false ;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char * kwnames[] = {
30128 (char *) "self",(char *) "name", NULL
30129 };
30130
30131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30133 if (!SWIG_IsOK(res1)) {
30134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30135 }
30136 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30137 {
30138 arg2 = wxString_in_helper(obj1);
30139 if (arg2 == NULL) SWIG_fail;
30140 temp2 = true;
30141 }
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 (arg1)->SetClassName((wxString const &)*arg2);
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 {
30150 if (temp2)
30151 delete arg2;
30152 }
30153 return resultobj;
30154 fail:
30155 {
30156 if (temp2)
30157 delete arg2;
30158 }
30159 return NULL;
30160 }
30161
30162
30163 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30164 PyObject *resultobj = 0;
30165 wxPyApp *arg1 = (wxPyApp *) 0 ;
30166 wxString *result = 0 ;
30167 void *argp1 = 0 ;
30168 int res1 = 0 ;
30169 PyObject *swig_obj[1] ;
30170
30171 if (!args) SWIG_fail;
30172 swig_obj[0] = args;
30173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30174 if (!SWIG_IsOK(res1)) {
30175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30176 }
30177 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 {
30181 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30182 result = (wxString *) &_result_ref;
30183 }
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 {
30188 #if wxUSE_UNICODE
30189 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30190 #else
30191 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30192 #endif
30193 }
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj = 0;
30202 wxPyApp *arg1 = (wxPyApp *) 0 ;
30203 wxString *arg2 = 0 ;
30204 void *argp1 = 0 ;
30205 int res1 = 0 ;
30206 bool temp2 = false ;
30207 PyObject * obj0 = 0 ;
30208 PyObject * obj1 = 0 ;
30209 char * kwnames[] = {
30210 (char *) "self",(char *) "name", NULL
30211 };
30212
30213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30215 if (!SWIG_IsOK(res1)) {
30216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30217 }
30218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30219 {
30220 arg2 = wxString_in_helper(obj1);
30221 if (arg2 == NULL) SWIG_fail;
30222 temp2 = true;
30223 }
30224 {
30225 PyThreadState* __tstate = wxPyBeginAllowThreads();
30226 (arg1)->SetVendorName((wxString const &)*arg2);
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 resultobj = SWIG_Py_Void();
30231 {
30232 if (temp2)
30233 delete arg2;
30234 }
30235 return resultobj;
30236 fail:
30237 {
30238 if (temp2)
30239 delete arg2;
30240 }
30241 return NULL;
30242 }
30243
30244
30245 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30246 PyObject *resultobj = 0;
30247 wxPyApp *arg1 = (wxPyApp *) 0 ;
30248 wxAppTraits *result = 0 ;
30249 void *argp1 = 0 ;
30250 int res1 = 0 ;
30251 PyObject *swig_obj[1] ;
30252
30253 if (!args) SWIG_fail;
30254 swig_obj[0] = args;
30255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30256 if (!SWIG_IsOK(res1)) {
30257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30258 }
30259 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30260 {
30261 PyThreadState* __tstate = wxPyBeginAllowThreads();
30262 result = (wxAppTraits *)(arg1)->GetTraits();
30263 wxPyEndAllowThreads(__tstate);
30264 if (PyErr_Occurred()) SWIG_fail;
30265 }
30266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30267 return resultobj;
30268 fail:
30269 return NULL;
30270 }
30271
30272
30273 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30274 PyObject *resultobj = 0;
30275 wxPyApp *arg1 = (wxPyApp *) 0 ;
30276 void *argp1 = 0 ;
30277 int res1 = 0 ;
30278 PyObject *swig_obj[1] ;
30279
30280 if (!args) SWIG_fail;
30281 swig_obj[0] = args;
30282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30283 if (!SWIG_IsOK(res1)) {
30284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30285 }
30286 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30287 {
30288 PyThreadState* __tstate = wxPyBeginAllowThreads();
30289 (arg1)->ProcessPendingEvents();
30290 wxPyEndAllowThreads(__tstate);
30291 if (PyErr_Occurred()) SWIG_fail;
30292 }
30293 resultobj = SWIG_Py_Void();
30294 return resultobj;
30295 fail:
30296 return NULL;
30297 }
30298
30299
30300 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30301 PyObject *resultobj = 0;
30302 wxPyApp *arg1 = (wxPyApp *) 0 ;
30303 bool arg2 = (bool) false ;
30304 bool result;
30305 void *argp1 = 0 ;
30306 int res1 = 0 ;
30307 bool val2 ;
30308 int ecode2 = 0 ;
30309 PyObject * obj0 = 0 ;
30310 PyObject * obj1 = 0 ;
30311 char * kwnames[] = {
30312 (char *) "self",(char *) "onlyIfNeeded", NULL
30313 };
30314
30315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30317 if (!SWIG_IsOK(res1)) {
30318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30319 }
30320 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30321 if (obj1) {
30322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30323 if (!SWIG_IsOK(ecode2)) {
30324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30325 }
30326 arg2 = static_cast< bool >(val2);
30327 }
30328 {
30329 PyThreadState* __tstate = wxPyBeginAllowThreads();
30330 result = (bool)(arg1)->Yield(arg2);
30331 wxPyEndAllowThreads(__tstate);
30332 if (PyErr_Occurred()) SWIG_fail;
30333 }
30334 {
30335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30336 }
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30344 PyObject *resultobj = 0;
30345 wxPyApp *arg1 = (wxPyApp *) 0 ;
30346 void *argp1 = 0 ;
30347 int res1 = 0 ;
30348 PyObject *swig_obj[1] ;
30349
30350 if (!args) SWIG_fail;
30351 swig_obj[0] = args;
30352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30353 if (!SWIG_IsOK(res1)) {
30354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30355 }
30356 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30357 {
30358 PyThreadState* __tstate = wxPyBeginAllowThreads();
30359 (arg1)->WakeUpIdle();
30360 wxPyEndAllowThreads(__tstate);
30361 if (PyErr_Occurred()) SWIG_fail;
30362 }
30363 resultobj = SWIG_Py_Void();
30364 return resultobj;
30365 fail:
30366 return NULL;
30367 }
30368
30369
30370 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30371 PyObject *resultobj = 0;
30372 bool result;
30373
30374 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 result = (bool)wxPyApp::IsMainLoopRunning();
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 {
30382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30383 }
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 PyObject *resultobj = 0;
30392 wxPyApp *arg1 = (wxPyApp *) 0 ;
30393 int result;
30394 void *argp1 = 0 ;
30395 int res1 = 0 ;
30396 PyObject *swig_obj[1] ;
30397
30398 if (!args) SWIG_fail;
30399 swig_obj[0] = args;
30400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30401 if (!SWIG_IsOK(res1)) {
30402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30403 }
30404 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 result = (int)(arg1)->MainLoop();
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 resultobj = SWIG_From_int(static_cast< int >(result));
30412 return resultobj;
30413 fail:
30414 return NULL;
30415 }
30416
30417
30418 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30419 PyObject *resultobj = 0;
30420 wxPyApp *arg1 = (wxPyApp *) 0 ;
30421 void *argp1 = 0 ;
30422 int res1 = 0 ;
30423 PyObject *swig_obj[1] ;
30424
30425 if (!args) SWIG_fail;
30426 swig_obj[0] = args;
30427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30428 if (!SWIG_IsOK(res1)) {
30429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30430 }
30431 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 (arg1)->Exit();
30435 wxPyEndAllowThreads(__tstate);
30436 if (PyErr_Occurred()) SWIG_fail;
30437 }
30438 resultobj = SWIG_Py_Void();
30439 return resultobj;
30440 fail:
30441 return NULL;
30442 }
30443
30444
30445 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30446 PyObject *resultobj = 0;
30447 wxPyApp *arg1 = (wxPyApp *) 0 ;
30448 wxLayoutDirection result;
30449 void *argp1 = 0 ;
30450 int res1 = 0 ;
30451 PyObject *swig_obj[1] ;
30452
30453 if (!args) SWIG_fail;
30454 swig_obj[0] = args;
30455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30456 if (!SWIG_IsOK(res1)) {
30457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30458 }
30459 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30460 {
30461 PyThreadState* __tstate = wxPyBeginAllowThreads();
30462 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30463 wxPyEndAllowThreads(__tstate);
30464 if (PyErr_Occurred()) SWIG_fail;
30465 }
30466 resultobj = SWIG_From_int(static_cast< int >(result));
30467 return resultobj;
30468 fail:
30469 return NULL;
30470 }
30471
30472
30473 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30474 PyObject *resultobj = 0;
30475 wxPyApp *arg1 = (wxPyApp *) 0 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 PyObject *swig_obj[1] ;
30479
30480 if (!args) SWIG_fail;
30481 swig_obj[0] = args;
30482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30483 if (!SWIG_IsOK(res1)) {
30484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30485 }
30486 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 (arg1)->ExitMainLoop();
30490 wxPyEndAllowThreads(__tstate);
30491 if (PyErr_Occurred()) SWIG_fail;
30492 }
30493 resultobj = SWIG_Py_Void();
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30501 PyObject *resultobj = 0;
30502 wxPyApp *arg1 = (wxPyApp *) 0 ;
30503 bool result;
30504 void *argp1 = 0 ;
30505 int res1 = 0 ;
30506 PyObject *swig_obj[1] ;
30507
30508 if (!args) SWIG_fail;
30509 swig_obj[0] = args;
30510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30511 if (!SWIG_IsOK(res1)) {
30512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30513 }
30514 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 result = (bool)(arg1)->Pending();
30518 wxPyEndAllowThreads(__tstate);
30519 if (PyErr_Occurred()) SWIG_fail;
30520 }
30521 {
30522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30523 }
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30531 PyObject *resultobj = 0;
30532 wxPyApp *arg1 = (wxPyApp *) 0 ;
30533 bool result;
30534 void *argp1 = 0 ;
30535 int res1 = 0 ;
30536 PyObject *swig_obj[1] ;
30537
30538 if (!args) SWIG_fail;
30539 swig_obj[0] = args;
30540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30541 if (!SWIG_IsOK(res1)) {
30542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30543 }
30544 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30545 {
30546 PyThreadState* __tstate = wxPyBeginAllowThreads();
30547 result = (bool)(arg1)->Dispatch();
30548 wxPyEndAllowThreads(__tstate);
30549 if (PyErr_Occurred()) SWIG_fail;
30550 }
30551 {
30552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30553 }
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30561 PyObject *resultobj = 0;
30562 wxPyApp *arg1 = (wxPyApp *) 0 ;
30563 bool result;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 PyObject *swig_obj[1] ;
30567
30568 if (!args) SWIG_fail;
30569 swig_obj[0] = args;
30570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30571 if (!SWIG_IsOK(res1)) {
30572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30573 }
30574 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30575 {
30576 PyThreadState* __tstate = wxPyBeginAllowThreads();
30577 result = (bool)(arg1)->ProcessIdle();
30578 wxPyEndAllowThreads(__tstate);
30579 if (PyErr_Occurred()) SWIG_fail;
30580 }
30581 {
30582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30583 }
30584 return resultobj;
30585 fail:
30586 return NULL;
30587 }
30588
30589
30590 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30591 PyObject *resultobj = 0;
30592 wxPyApp *arg1 = (wxPyApp *) 0 ;
30593 wxWindow *arg2 = (wxWindow *) 0 ;
30594 wxIdleEvent *arg3 = 0 ;
30595 bool result;
30596 void *argp1 = 0 ;
30597 int res1 = 0 ;
30598 void *argp2 = 0 ;
30599 int res2 = 0 ;
30600 void *argp3 = 0 ;
30601 int res3 = 0 ;
30602 PyObject * obj0 = 0 ;
30603 PyObject * obj1 = 0 ;
30604 PyObject * obj2 = 0 ;
30605 char * kwnames[] = {
30606 (char *) "self",(char *) "win",(char *) "event", NULL
30607 };
30608
30609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30613 }
30614 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30616 if (!SWIG_IsOK(res2)) {
30617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30618 }
30619 arg2 = reinterpret_cast< wxWindow * >(argp2);
30620 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30621 if (!SWIG_IsOK(res3)) {
30622 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30623 }
30624 if (!argp3) {
30625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30626 }
30627 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 {
30635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30636 }
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30644 PyObject *resultobj = 0;
30645 wxPyApp *arg1 = (wxPyApp *) 0 ;
30646 bool result;
30647 void *argp1 = 0 ;
30648 int res1 = 0 ;
30649 PyObject *swig_obj[1] ;
30650
30651 if (!args) SWIG_fail;
30652 swig_obj[0] = args;
30653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30656 }
30657 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = (bool)((wxPyApp const *)arg1)->IsActive();
30661 wxPyEndAllowThreads(__tstate);
30662 if (PyErr_Occurred()) SWIG_fail;
30663 }
30664 {
30665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30666 }
30667 return resultobj;
30668 fail:
30669 return NULL;
30670 }
30671
30672
30673 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30674 PyObject *resultobj = 0;
30675 wxPyApp *arg1 = (wxPyApp *) 0 ;
30676 wxWindow *arg2 = (wxWindow *) 0 ;
30677 void *argp1 = 0 ;
30678 int res1 = 0 ;
30679 void *argp2 = 0 ;
30680 int res2 = 0 ;
30681 PyObject * obj0 = 0 ;
30682 PyObject * obj1 = 0 ;
30683 char * kwnames[] = {
30684 (char *) "self",(char *) "win", NULL
30685 };
30686
30687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30689 if (!SWIG_IsOK(res1)) {
30690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30691 }
30692 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30693 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30694 if (!SWIG_IsOK(res2)) {
30695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30696 }
30697 arg2 = reinterpret_cast< wxWindow * >(argp2);
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 (arg1)->SetTopWindow(arg2);
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 resultobj = SWIG_Py_Void();
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30712 PyObject *resultobj = 0;
30713 wxPyApp *arg1 = (wxPyApp *) 0 ;
30714 wxWindow *result = 0 ;
30715 void *argp1 = 0 ;
30716 int res1 = 0 ;
30717 PyObject *swig_obj[1] ;
30718
30719 if (!args) SWIG_fail;
30720 swig_obj[0] = args;
30721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30722 if (!SWIG_IsOK(res1)) {
30723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30724 }
30725 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 {
30733 resultobj = wxPyMake_wxObject(result, (bool)0);
30734 }
30735 return resultobj;
30736 fail:
30737 return NULL;
30738 }
30739
30740
30741 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30742 PyObject *resultobj = 0;
30743 wxPyApp *arg1 = (wxPyApp *) 0 ;
30744 bool arg2 ;
30745 void *argp1 = 0 ;
30746 int res1 = 0 ;
30747 bool val2 ;
30748 int ecode2 = 0 ;
30749 PyObject * obj0 = 0 ;
30750 PyObject * obj1 = 0 ;
30751 char * kwnames[] = {
30752 (char *) "self",(char *) "flag", NULL
30753 };
30754
30755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30757 if (!SWIG_IsOK(res1)) {
30758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30759 }
30760 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30762 if (!SWIG_IsOK(ecode2)) {
30763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30764 }
30765 arg2 = static_cast< bool >(val2);
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 (arg1)->SetExitOnFrameDelete(arg2);
30769 wxPyEndAllowThreads(__tstate);
30770 if (PyErr_Occurred()) SWIG_fail;
30771 }
30772 resultobj = SWIG_Py_Void();
30773 return resultobj;
30774 fail:
30775 return NULL;
30776 }
30777
30778
30779 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30780 PyObject *resultobj = 0;
30781 wxPyApp *arg1 = (wxPyApp *) 0 ;
30782 bool result;
30783 void *argp1 = 0 ;
30784 int res1 = 0 ;
30785 PyObject *swig_obj[1] ;
30786
30787 if (!args) SWIG_fail;
30788 swig_obj[0] = args;
30789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30790 if (!SWIG_IsOK(res1)) {
30791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30792 }
30793 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30794 {
30795 PyThreadState* __tstate = wxPyBeginAllowThreads();
30796 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 {
30801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30802 }
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30810 PyObject *resultobj = 0;
30811 wxPyApp *arg1 = (wxPyApp *) 0 ;
30812 bool arg2 ;
30813 void *argp1 = 0 ;
30814 int res1 = 0 ;
30815 bool val2 ;
30816 int ecode2 = 0 ;
30817 PyObject * obj0 = 0 ;
30818 PyObject * obj1 = 0 ;
30819 char * kwnames[] = {
30820 (char *) "self",(char *) "flag", NULL
30821 };
30822
30823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30825 if (!SWIG_IsOK(res1)) {
30826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30827 }
30828 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30830 if (!SWIG_IsOK(ecode2)) {
30831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30832 }
30833 arg2 = static_cast< bool >(val2);
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 (arg1)->SetUseBestVisual(arg2);
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_Py_Void();
30841 return resultobj;
30842 fail:
30843 return NULL;
30844 }
30845
30846
30847 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30848 PyObject *resultobj = 0;
30849 wxPyApp *arg1 = (wxPyApp *) 0 ;
30850 bool result;
30851 void *argp1 = 0 ;
30852 int res1 = 0 ;
30853 PyObject *swig_obj[1] ;
30854
30855 if (!args) SWIG_fail;
30856 swig_obj[0] = args;
30857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30858 if (!SWIG_IsOK(res1)) {
30859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30860 }
30861 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30865 wxPyEndAllowThreads(__tstate);
30866 if (PyErr_Occurred()) SWIG_fail;
30867 }
30868 {
30869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30870 }
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30878 PyObject *resultobj = 0;
30879 wxPyApp *arg1 = (wxPyApp *) 0 ;
30880 int arg2 ;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 int val2 ;
30884 int ecode2 = 0 ;
30885 PyObject * obj0 = 0 ;
30886 PyObject * obj1 = 0 ;
30887 char * kwnames[] = {
30888 (char *) "self",(char *) "mode", NULL
30889 };
30890
30891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30893 if (!SWIG_IsOK(res1)) {
30894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30895 }
30896 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30897 ecode2 = SWIG_AsVal_int(obj1, &val2);
30898 if (!SWIG_IsOK(ecode2)) {
30899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30900 }
30901 arg2 = static_cast< int >(val2);
30902 {
30903 PyThreadState* __tstate = wxPyBeginAllowThreads();
30904 (arg1)->SetPrintMode(arg2);
30905 wxPyEndAllowThreads(__tstate);
30906 if (PyErr_Occurred()) SWIG_fail;
30907 }
30908 resultobj = SWIG_Py_Void();
30909 return resultobj;
30910 fail:
30911 return NULL;
30912 }
30913
30914
30915 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30916 PyObject *resultobj = 0;
30917 wxPyApp *arg1 = (wxPyApp *) 0 ;
30918 int result;
30919 void *argp1 = 0 ;
30920 int res1 = 0 ;
30921 PyObject *swig_obj[1] ;
30922
30923 if (!args) SWIG_fail;
30924 swig_obj[0] = args;
30925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30926 if (!SWIG_IsOK(res1)) {
30927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30928 }
30929 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30930 {
30931 PyThreadState* __tstate = wxPyBeginAllowThreads();
30932 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30933 wxPyEndAllowThreads(__tstate);
30934 if (PyErr_Occurred()) SWIG_fail;
30935 }
30936 resultobj = SWIG_From_int(static_cast< int >(result));
30937 return resultobj;
30938 fail:
30939 return NULL;
30940 }
30941
30942
30943 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30944 PyObject *resultobj = 0;
30945 wxPyApp *arg1 = (wxPyApp *) 0 ;
30946 int arg2 ;
30947 void *argp1 = 0 ;
30948 int res1 = 0 ;
30949 int val2 ;
30950 int ecode2 = 0 ;
30951 PyObject * obj0 = 0 ;
30952 PyObject * obj1 = 0 ;
30953 char * kwnames[] = {
30954 (char *) "self",(char *) "mode", NULL
30955 };
30956
30957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30959 if (!SWIG_IsOK(res1)) {
30960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30961 }
30962 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30963 ecode2 = SWIG_AsVal_int(obj1, &val2);
30964 if (!SWIG_IsOK(ecode2)) {
30965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30966 }
30967 arg2 = static_cast< int >(val2);
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 (arg1)->SetAssertMode(arg2);
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 resultobj = SWIG_Py_Void();
30975 return resultobj;
30976 fail:
30977 return NULL;
30978 }
30979
30980
30981 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30982 PyObject *resultobj = 0;
30983 wxPyApp *arg1 = (wxPyApp *) 0 ;
30984 int result;
30985 void *argp1 = 0 ;
30986 int res1 = 0 ;
30987 PyObject *swig_obj[1] ;
30988
30989 if (!args) SWIG_fail;
30990 swig_obj[0] = args;
30991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30992 if (!SWIG_IsOK(res1)) {
30993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30994 }
30995 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = (int)(arg1)->GetAssertMode();
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 resultobj = SWIG_From_int(static_cast< int >(result));
31003 return resultobj;
31004 fail:
31005 return NULL;
31006 }
31007
31008
31009 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31010 PyObject *resultobj = 0;
31011 bool result;
31012
31013 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31014 {
31015 PyThreadState* __tstate = wxPyBeginAllowThreads();
31016 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31017 wxPyEndAllowThreads(__tstate);
31018 if (PyErr_Occurred()) SWIG_fail;
31019 }
31020 {
31021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31022 }
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31030 PyObject *resultobj = 0;
31031 long result;
31032
31033 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31034 {
31035 PyThreadState* __tstate = wxPyBeginAllowThreads();
31036 result = (long)wxPyApp::GetMacAboutMenuItemId();
31037 wxPyEndAllowThreads(__tstate);
31038 if (PyErr_Occurred()) SWIG_fail;
31039 }
31040 resultobj = SWIG_From_long(static_cast< long >(result));
31041 return resultobj;
31042 fail:
31043 return NULL;
31044 }
31045
31046
31047 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31048 PyObject *resultobj = 0;
31049 long result;
31050
31051 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31052 {
31053 PyThreadState* __tstate = wxPyBeginAllowThreads();
31054 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 resultobj = SWIG_From_long(static_cast< long >(result));
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31066 PyObject *resultobj = 0;
31067 long result;
31068
31069 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = (long)wxPyApp::GetMacExitMenuItemId();
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 resultobj = SWIG_From_long(static_cast< long >(result));
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31084 PyObject *resultobj = 0;
31085 wxString result;
31086
31087 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31088 {
31089 PyThreadState* __tstate = wxPyBeginAllowThreads();
31090 result = wxPyApp::GetMacHelpMenuTitleName();
31091 wxPyEndAllowThreads(__tstate);
31092 if (PyErr_Occurred()) SWIG_fail;
31093 }
31094 {
31095 #if wxUSE_UNICODE
31096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31097 #else
31098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31099 #endif
31100 }
31101 return resultobj;
31102 fail:
31103 return NULL;
31104 }
31105
31106
31107 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31108 PyObject *resultobj = 0;
31109 bool arg1 ;
31110 bool val1 ;
31111 int ecode1 = 0 ;
31112 PyObject * obj0 = 0 ;
31113 char * kwnames[] = {
31114 (char *) "val", NULL
31115 };
31116
31117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31118 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31119 if (!SWIG_IsOK(ecode1)) {
31120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31121 }
31122 arg1 = static_cast< bool >(val1);
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_Py_Void();
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31137 PyObject *resultobj = 0;
31138 long arg1 ;
31139 long val1 ;
31140 int ecode1 = 0 ;
31141 PyObject * obj0 = 0 ;
31142 char * kwnames[] = {
31143 (char *) "val", NULL
31144 };
31145
31146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31147 ecode1 = SWIG_AsVal_long(obj0, &val1);
31148 if (!SWIG_IsOK(ecode1)) {
31149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31150 }
31151 arg1 = static_cast< long >(val1);
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 wxPyApp::SetMacAboutMenuItemId(arg1);
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 resultobj = SWIG_Py_Void();
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31166 PyObject *resultobj = 0;
31167 long arg1 ;
31168 long val1 ;
31169 int ecode1 = 0 ;
31170 PyObject * obj0 = 0 ;
31171 char * kwnames[] = {
31172 (char *) "val", NULL
31173 };
31174
31175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31176 ecode1 = SWIG_AsVal_long(obj0, &val1);
31177 if (!SWIG_IsOK(ecode1)) {
31178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31179 }
31180 arg1 = static_cast< long >(val1);
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj = 0;
31196 long arg1 ;
31197 long val1 ;
31198 int ecode1 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 char * kwnames[] = {
31201 (char *) "val", NULL
31202 };
31203
31204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31205 ecode1 = SWIG_AsVal_long(obj0, &val1);
31206 if (!SWIG_IsOK(ecode1)) {
31207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31208 }
31209 arg1 = static_cast< long >(val1);
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 wxPyApp::SetMacExitMenuItemId(arg1);
31213 wxPyEndAllowThreads(__tstate);
31214 if (PyErr_Occurred()) SWIG_fail;
31215 }
31216 resultobj = SWIG_Py_Void();
31217 return resultobj;
31218 fail:
31219 return NULL;
31220 }
31221
31222
31223 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31224 PyObject *resultobj = 0;
31225 wxString *arg1 = 0 ;
31226 bool temp1 = false ;
31227 PyObject * obj0 = 0 ;
31228 char * kwnames[] = {
31229 (char *) "val", NULL
31230 };
31231
31232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31233 {
31234 arg1 = wxString_in_helper(obj0);
31235 if (arg1 == NULL) SWIG_fail;
31236 temp1 = true;
31237 }
31238 {
31239 PyThreadState* __tstate = wxPyBeginAllowThreads();
31240 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 resultobj = SWIG_Py_Void();
31245 {
31246 if (temp1)
31247 delete arg1;
31248 }
31249 return resultobj;
31250 fail:
31251 {
31252 if (temp1)
31253 delete arg1;
31254 }
31255 return NULL;
31256 }
31257
31258
31259 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31260 PyObject *resultobj = 0;
31261 wxPyApp *arg1 = (wxPyApp *) 0 ;
31262 void *argp1 = 0 ;
31263 int res1 = 0 ;
31264 PyObject *swig_obj[1] ;
31265
31266 if (!args) SWIG_fail;
31267 swig_obj[0] = args;
31268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31269 if (!SWIG_IsOK(res1)) {
31270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31271 }
31272 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 (arg1)->_BootstrapApp();
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 resultobj = SWIG_Py_Void();
31280 return resultobj;
31281 fail:
31282 return NULL;
31283 }
31284
31285
31286 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31287 PyObject *resultobj = 0;
31288 int result;
31289
31290 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 result = (int)wxPyApp::GetComCtl32Version();
31294 wxPyEndAllowThreads(__tstate);
31295 if (PyErr_Occurred()) SWIG_fail;
31296 }
31297 resultobj = SWIG_From_int(static_cast< int >(result));
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31305 PyObject *resultobj = 0;
31306 bool result;
31307
31308 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31309 {
31310 PyThreadState* __tstate = wxPyBeginAllowThreads();
31311 result = (bool)wxPyApp_IsDisplayAvailable();
31312 wxPyEndAllowThreads(__tstate);
31313 if (PyErr_Occurred()) SWIG_fail;
31314 }
31315 {
31316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31317 }
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31325 PyObject *obj;
31326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31327 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31328 return SWIG_Py_Void();
31329 }
31330
31331 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31332 return SWIG_Python_InitShadowInstance(args);
31333 }
31334
31335 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31336 PyObject *resultobj = 0;
31337
31338 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31339 {
31340 PyThreadState* __tstate = wxPyBeginAllowThreads();
31341 wxExit();
31342 wxPyEndAllowThreads(__tstate);
31343 if (PyErr_Occurred()) SWIG_fail;
31344 }
31345 resultobj = SWIG_Py_Void();
31346 return resultobj;
31347 fail:
31348 return NULL;
31349 }
31350
31351
31352 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31353 PyObject *resultobj = 0;
31354 bool result;
31355
31356 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 result = (bool)wxYield();
31360 wxPyEndAllowThreads(__tstate);
31361 if (PyErr_Occurred()) SWIG_fail;
31362 }
31363 {
31364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31365 }
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31373 PyObject *resultobj = 0;
31374 bool result;
31375
31376 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31377 {
31378 PyThreadState* __tstate = wxPyBeginAllowThreads();
31379 result = (bool)wxYieldIfNeeded();
31380 wxPyEndAllowThreads(__tstate);
31381 if (PyErr_Occurred()) SWIG_fail;
31382 }
31383 {
31384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31385 }
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31393 PyObject *resultobj = 0;
31394 wxWindow *arg1 = (wxWindow *) NULL ;
31395 bool arg2 = (bool) false ;
31396 bool result;
31397 void *argp1 = 0 ;
31398 int res1 = 0 ;
31399 bool val2 ;
31400 int ecode2 = 0 ;
31401 PyObject * obj0 = 0 ;
31402 PyObject * obj1 = 0 ;
31403 char * kwnames[] = {
31404 (char *) "win",(char *) "onlyIfNeeded", NULL
31405 };
31406
31407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31408 if (obj0) {
31409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31410 if (!SWIG_IsOK(res1)) {
31411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31412 }
31413 arg1 = reinterpret_cast< wxWindow * >(argp1);
31414 }
31415 if (obj1) {
31416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31417 if (!SWIG_IsOK(ecode2)) {
31418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31419 }
31420 arg2 = static_cast< bool >(val2);
31421 }
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = (bool)wxSafeYield(arg1,arg2);
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 {
31429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31430 }
31431 return resultobj;
31432 fail:
31433 return NULL;
31434 }
31435
31436
31437 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31438 PyObject *resultobj = 0;
31439
31440 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31441 {
31442 PyThreadState* __tstate = wxPyBeginAllowThreads();
31443 wxWakeUpIdle();
31444 wxPyEndAllowThreads(__tstate);
31445 if (PyErr_Occurred()) SWIG_fail;
31446 }
31447 resultobj = SWIG_Py_Void();
31448 return resultobj;
31449 fail:
31450 return NULL;
31451 }
31452
31453
31454 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31455 PyObject *resultobj = 0;
31456 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31457 wxEvent *arg2 = 0 ;
31458 void *argp1 = 0 ;
31459 int res1 = 0 ;
31460 void *argp2 = 0 ;
31461 int res2 = 0 ;
31462 PyObject * obj0 = 0 ;
31463 PyObject * obj1 = 0 ;
31464 char * kwnames[] = {
31465 (char *) "dest",(char *) "event", NULL
31466 };
31467
31468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31470 if (!SWIG_IsOK(res1)) {
31471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31472 }
31473 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31475 if (!SWIG_IsOK(res2)) {
31476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31477 }
31478 if (!argp2) {
31479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31480 }
31481 arg2 = reinterpret_cast< wxEvent * >(argp2);
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 wxPostEvent(arg1,*arg2);
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 resultobj = SWIG_Py_Void();
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31496 PyObject *resultobj = 0;
31497
31498 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 wxApp_CleanUp();
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 resultobj = SWIG_Py_Void();
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31513 PyObject *resultobj = 0;
31514 wxPyApp *result = 0 ;
31515
31516 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31517 {
31518 PyThreadState* __tstate = wxPyBeginAllowThreads();
31519 result = (wxPyApp *)wxPyGetApp();
31520 wxPyEndAllowThreads(__tstate);
31521 if (PyErr_Occurred()) SWIG_fail;
31522 }
31523 {
31524 resultobj = wxPyMake_wxObject(result, 0);
31525 }
31526 return resultobj;
31527 fail:
31528 return NULL;
31529 }
31530
31531
31532 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31533 PyObject *resultobj = 0;
31534 char *arg1 = (char *) 0 ;
31535 int res1 ;
31536 char *buf1 = 0 ;
31537 int alloc1 = 0 ;
31538 PyObject * obj0 = 0 ;
31539 char * kwnames[] = {
31540 (char *) "encoding", NULL
31541 };
31542
31543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31544 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31545 if (!SWIG_IsOK(res1)) {
31546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31547 }
31548 arg1 = buf1;
31549 {
31550 PyThreadState* __tstate = wxPyBeginAllowThreads();
31551 wxSetDefaultPyEncoding((char const *)arg1);
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 resultobj = SWIG_Py_Void();
31556 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31557 return resultobj;
31558 fail:
31559 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31560 return NULL;
31561 }
31562
31563
31564 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31565 PyObject *resultobj = 0;
31566 char *result = 0 ;
31567
31568 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31569 {
31570 PyThreadState* __tstate = wxPyBeginAllowThreads();
31571 result = (char *)wxGetDefaultPyEncoding();
31572 wxPyEndAllowThreads(__tstate);
31573 if (PyErr_Occurred()) SWIG_fail;
31574 }
31575 resultobj = SWIG_FromCharPtr(result);
31576 return resultobj;
31577 fail:
31578 return NULL;
31579 }
31580
31581
31582 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31583 PyObject *resultobj = 0;
31584 wxEventLoop *result = 0 ;
31585
31586 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31587 {
31588 PyThreadState* __tstate = wxPyBeginAllowThreads();
31589 result = (wxEventLoop *)new wxEventLoop();
31590 wxPyEndAllowThreads(__tstate);
31591 if (PyErr_Occurred()) SWIG_fail;
31592 }
31593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31594 return resultobj;
31595 fail:
31596 return NULL;
31597 }
31598
31599
31600 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31601 PyObject *resultobj = 0;
31602 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31603 void *argp1 = 0 ;
31604 int res1 = 0 ;
31605 PyObject *swig_obj[1] ;
31606
31607 if (!args) SWIG_fail;
31608 swig_obj[0] = args;
31609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31610 if (!SWIG_IsOK(res1)) {
31611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31612 }
31613 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31614 {
31615 PyThreadState* __tstate = wxPyBeginAllowThreads();
31616 delete arg1;
31617
31618 wxPyEndAllowThreads(__tstate);
31619 if (PyErr_Occurred()) SWIG_fail;
31620 }
31621 resultobj = SWIG_Py_Void();
31622 return resultobj;
31623 fail:
31624 return NULL;
31625 }
31626
31627
31628 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31629 PyObject *resultobj = 0;
31630 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31631 int result;
31632 void *argp1 = 0 ;
31633 int res1 = 0 ;
31634 PyObject *swig_obj[1] ;
31635
31636 if (!args) SWIG_fail;
31637 swig_obj[0] = args;
31638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31639 if (!SWIG_IsOK(res1)) {
31640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31641 }
31642 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 result = (int)(arg1)->Run();
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 resultobj = SWIG_From_int(static_cast< int >(result));
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31657 PyObject *resultobj = 0;
31658 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31659 int arg2 = (int) 0 ;
31660 void *argp1 = 0 ;
31661 int res1 = 0 ;
31662 int val2 ;
31663 int ecode2 = 0 ;
31664 PyObject * obj0 = 0 ;
31665 PyObject * obj1 = 0 ;
31666 char * kwnames[] = {
31667 (char *) "self",(char *) "rc", NULL
31668 };
31669
31670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31672 if (!SWIG_IsOK(res1)) {
31673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31674 }
31675 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31676 if (obj1) {
31677 ecode2 = SWIG_AsVal_int(obj1, &val2);
31678 if (!SWIG_IsOK(ecode2)) {
31679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31680 }
31681 arg2 = static_cast< int >(val2);
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 (arg1)->Exit(arg2);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_Py_Void();
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31697 PyObject *resultobj = 0;
31698 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31699 bool result;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 PyObject *swig_obj[1] ;
31703
31704 if (!args) SWIG_fail;
31705 swig_obj[0] = args;
31706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31707 if (!SWIG_IsOK(res1)) {
31708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31709 }
31710 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31711 {
31712 PyThreadState* __tstate = wxPyBeginAllowThreads();
31713 result = (bool)((wxEventLoop const *)arg1)->Pending();
31714 wxPyEndAllowThreads(__tstate);
31715 if (PyErr_Occurred()) SWIG_fail;
31716 }
31717 {
31718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31719 }
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31727 PyObject *resultobj = 0;
31728 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31729 bool result;
31730 void *argp1 = 0 ;
31731 int res1 = 0 ;
31732 PyObject *swig_obj[1] ;
31733
31734 if (!args) SWIG_fail;
31735 swig_obj[0] = args;
31736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31737 if (!SWIG_IsOK(res1)) {
31738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31739 }
31740 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31741 {
31742 PyThreadState* __tstate = wxPyBeginAllowThreads();
31743 result = (bool)(arg1)->Dispatch();
31744 wxPyEndAllowThreads(__tstate);
31745 if (PyErr_Occurred()) SWIG_fail;
31746 }
31747 {
31748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31749 }
31750 return resultobj;
31751 fail:
31752 return NULL;
31753 }
31754
31755
31756 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31757 PyObject *resultobj = 0;
31758 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31759 bool result;
31760 void *argp1 = 0 ;
31761 int res1 = 0 ;
31762 PyObject *swig_obj[1] ;
31763
31764 if (!args) SWIG_fail;
31765 swig_obj[0] = args;
31766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31769 }
31770 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31774 wxPyEndAllowThreads(__tstate);
31775 if (PyErr_Occurred()) SWIG_fail;
31776 }
31777 {
31778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31779 }
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxEventLoop *result = 0 ;
31789
31790 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 result = (wxEventLoop *)wxEventLoop::GetActive();
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31798 return resultobj;
31799 fail:
31800 return NULL;
31801 }
31802
31803
31804 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31805 PyObject *resultobj = 0;
31806 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31807 void *argp1 = 0 ;
31808 int res1 = 0 ;
31809 PyObject * obj0 = 0 ;
31810 char * kwnames[] = {
31811 (char *) "loop", NULL
31812 };
31813
31814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31816 if (!SWIG_IsOK(res1)) {
31817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31818 }
31819 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31820 {
31821 PyThreadState* __tstate = wxPyBeginAllowThreads();
31822 wxEventLoop::SetActive(arg1);
31823 wxPyEndAllowThreads(__tstate);
31824 if (PyErr_Occurred()) SWIG_fail;
31825 }
31826 resultobj = SWIG_Py_Void();
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31834 PyObject *obj;
31835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31836 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31837 return SWIG_Py_Void();
31838 }
31839
31840 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31841 return SWIG_Python_InitShadowInstance(args);
31842 }
31843
31844 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31845 PyObject *resultobj = 0;
31846 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31847 wxEventLoopActivator *result = 0 ;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 PyObject * obj0 = 0 ;
31851 char * kwnames[] = {
31852 (char *) "evtLoop", NULL
31853 };
31854
31855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31859 }
31860 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31861 {
31862 PyThreadState* __tstate = wxPyBeginAllowThreads();
31863 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31875 PyObject *resultobj = 0;
31876 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31877 void *argp1 = 0 ;
31878 int res1 = 0 ;
31879 PyObject *swig_obj[1] ;
31880
31881 if (!args) SWIG_fail;
31882 swig_obj[0] = args;
31883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31884 if (!SWIG_IsOK(res1)) {
31885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31886 }
31887 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31888 {
31889 PyThreadState* __tstate = wxPyBeginAllowThreads();
31890 delete arg1;
31891
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 resultobj = SWIG_Py_Void();
31896 return resultobj;
31897 fail:
31898 return NULL;
31899 }
31900
31901
31902 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31903 PyObject *obj;
31904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31905 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31906 return SWIG_Py_Void();
31907 }
31908
31909 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31910 return SWIG_Python_InitShadowInstance(args);
31911 }
31912
31913 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31914 PyObject *resultobj = 0;
31915 int arg1 = (int) 0 ;
31916 int arg2 = (int) 0 ;
31917 int arg3 = (int) 0 ;
31918 wxAcceleratorEntry *result = 0 ;
31919 int val1 ;
31920 int ecode1 = 0 ;
31921 int val2 ;
31922 int ecode2 = 0 ;
31923 int val3 ;
31924 int ecode3 = 0 ;
31925 PyObject * obj0 = 0 ;
31926 PyObject * obj1 = 0 ;
31927 PyObject * obj2 = 0 ;
31928 char * kwnames[] = {
31929 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31930 };
31931
31932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31933 if (obj0) {
31934 ecode1 = SWIG_AsVal_int(obj0, &val1);
31935 if (!SWIG_IsOK(ecode1)) {
31936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31937 }
31938 arg1 = static_cast< int >(val1);
31939 }
31940 if (obj1) {
31941 ecode2 = SWIG_AsVal_int(obj1, &val2);
31942 if (!SWIG_IsOK(ecode2)) {
31943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31944 }
31945 arg2 = static_cast< int >(val2);
31946 }
31947 if (obj2) {
31948 ecode3 = SWIG_AsVal_int(obj2, &val3);
31949 if (!SWIG_IsOK(ecode3)) {
31950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31951 }
31952 arg3 = static_cast< int >(val3);
31953 }
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31968 PyObject *resultobj = 0;
31969 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31970 void *argp1 = 0 ;
31971 int res1 = 0 ;
31972 PyObject *swig_obj[1] ;
31973
31974 if (!args) SWIG_fail;
31975 swig_obj[0] = args;
31976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31977 if (!SWIG_IsOK(res1)) {
31978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31979 }
31980 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31981 {
31982 PyThreadState* __tstate = wxPyBeginAllowThreads();
31983 delete arg1;
31984
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 resultobj = SWIG_Py_Void();
31989 return resultobj;
31990 fail:
31991 return NULL;
31992 }
31993
31994
31995 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31996 PyObject *resultobj = 0;
31997 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31998 int arg2 ;
31999 int arg3 ;
32000 int arg4 ;
32001 void *argp1 = 0 ;
32002 int res1 = 0 ;
32003 int val2 ;
32004 int ecode2 = 0 ;
32005 int val3 ;
32006 int ecode3 = 0 ;
32007 int val4 ;
32008 int ecode4 = 0 ;
32009 PyObject * obj0 = 0 ;
32010 PyObject * obj1 = 0 ;
32011 PyObject * obj2 = 0 ;
32012 PyObject * obj3 = 0 ;
32013 char * kwnames[] = {
32014 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32015 };
32016
32017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32019 if (!SWIG_IsOK(res1)) {
32020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32021 }
32022 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32023 ecode2 = SWIG_AsVal_int(obj1, &val2);
32024 if (!SWIG_IsOK(ecode2)) {
32025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32026 }
32027 arg2 = static_cast< int >(val2);
32028 ecode3 = SWIG_AsVal_int(obj2, &val3);
32029 if (!SWIG_IsOK(ecode3)) {
32030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32031 }
32032 arg3 = static_cast< int >(val3);
32033 ecode4 = SWIG_AsVal_int(obj3, &val4);
32034 if (!SWIG_IsOK(ecode4)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32036 }
32037 arg4 = static_cast< int >(val4);
32038 {
32039 PyThreadState* __tstate = wxPyBeginAllowThreads();
32040 (arg1)->Set(arg2,arg3,arg4);
32041 wxPyEndAllowThreads(__tstate);
32042 if (PyErr_Occurred()) SWIG_fail;
32043 }
32044 resultobj = SWIG_Py_Void();
32045 return resultobj;
32046 fail:
32047 return NULL;
32048 }
32049
32050
32051 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32052 PyObject *resultobj = 0;
32053 wxString *arg1 = 0 ;
32054 wxAcceleratorEntry *result = 0 ;
32055 bool temp1 = false ;
32056 PyObject * obj0 = 0 ;
32057 char * kwnames[] = {
32058 (char *) "str", NULL
32059 };
32060
32061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32062 {
32063 arg1 = wxString_in_helper(obj0);
32064 if (arg1 == NULL) SWIG_fail;
32065 temp1 = true;
32066 }
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32074 {
32075 if (temp1)
32076 delete arg1;
32077 }
32078 return resultobj;
32079 fail:
32080 {
32081 if (temp1)
32082 delete arg1;
32083 }
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *resultobj = 0;
32090 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32091 int result;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 PyObject *swig_obj[1] ;
32095
32096 if (!args) SWIG_fail;
32097 swig_obj[0] = args;
32098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32099 if (!SWIG_IsOK(res1)) {
32100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32101 }
32102 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 result = (int)(arg1)->GetFlags();
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_From_int(static_cast< int >(result));
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32119 int result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 PyObject *swig_obj[1] ;
32123
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32129 }
32130 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (int)(arg1)->GetKeyCode();
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_From_int(static_cast< int >(result));
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32147 int result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 PyObject *swig_obj[1] ;
32151
32152 if (!args) SWIG_fail;
32153 swig_obj[0] = args;
32154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32157 }
32158 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (int)(arg1)->GetCommand();
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 resultobj = SWIG_From_int(static_cast< int >(result));
32166 return resultobj;
32167 fail:
32168 return NULL;
32169 }
32170
32171
32172 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32173 PyObject *resultobj = 0;
32174 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32175 bool result;
32176 void *argp1 = 0 ;
32177 int res1 = 0 ;
32178 PyObject *swig_obj[1] ;
32179
32180 if (!args) SWIG_fail;
32181 swig_obj[0] = args;
32182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32183 if (!SWIG_IsOK(res1)) {
32184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32185 }
32186 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 {
32194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32195 }
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32203 PyObject *resultobj = 0;
32204 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32205 wxString result;
32206 void *argp1 = 0 ;
32207 int res1 = 0 ;
32208 PyObject *swig_obj[1] ;
32209
32210 if (!args) SWIG_fail;
32211 swig_obj[0] = args;
32212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32213 if (!SWIG_IsOK(res1)) {
32214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32215 }
32216 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32217 {
32218 PyThreadState* __tstate = wxPyBeginAllowThreads();
32219 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 {
32224 #if wxUSE_UNICODE
32225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32226 #else
32227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32228 #endif
32229 }
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32237 PyObject *resultobj = 0;
32238 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32239 wxString *arg2 = 0 ;
32240 bool result;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 bool temp2 = false ;
32244 PyObject * obj0 = 0 ;
32245 PyObject * obj1 = 0 ;
32246 char * kwnames[] = {
32247 (char *) "self",(char *) "str", NULL
32248 };
32249
32250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32252 if (!SWIG_IsOK(res1)) {
32253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32254 }
32255 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32256 {
32257 arg2 = wxString_in_helper(obj1);
32258 if (arg2 == NULL) SWIG_fail;
32259 temp2 = true;
32260 }
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 {
32268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32269 }
32270 {
32271 if (temp2)
32272 delete arg2;
32273 }
32274 return resultobj;
32275 fail:
32276 {
32277 if (temp2)
32278 delete arg2;
32279 }
32280 return NULL;
32281 }
32282
32283
32284 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32285 PyObject *obj;
32286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32287 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32288 return SWIG_Py_Void();
32289 }
32290
32291 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32292 return SWIG_Python_InitShadowInstance(args);
32293 }
32294
32295 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32296 PyObject *resultobj = 0;
32297 int arg1 ;
32298 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32299 wxAcceleratorTable *result = 0 ;
32300 PyObject * obj0 = 0 ;
32301 char * kwnames[] = {
32302 (char *) "n", NULL
32303 };
32304
32305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32306 {
32307 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32308 if (arg2) arg1 = PyList_Size(obj0);
32309 else arg1 = 0;
32310 }
32311 {
32312 PyThreadState* __tstate = wxPyBeginAllowThreads();
32313 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32325 PyObject *resultobj = 0;
32326 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
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_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32334 if (!SWIG_IsOK(res1)) {
32335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32336 }
32337 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32338 {
32339 PyThreadState* __tstate = wxPyBeginAllowThreads();
32340 delete arg1;
32341
32342 wxPyEndAllowThreads(__tstate);
32343 if (PyErr_Occurred()) SWIG_fail;
32344 }
32345 resultobj = SWIG_Py_Void();
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32353 PyObject *resultobj = 0;
32354 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32355 bool result;
32356 void *argp1 = 0 ;
32357 int res1 = 0 ;
32358 PyObject *swig_obj[1] ;
32359
32360 if (!args) SWIG_fail;
32361 swig_obj[0] = args;
32362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32363 if (!SWIG_IsOK(res1)) {
32364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32365 }
32366 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32367 {
32368 PyThreadState* __tstate = wxPyBeginAllowThreads();
32369 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32370 wxPyEndAllowThreads(__tstate);
32371 if (PyErr_Occurred()) SWIG_fail;
32372 }
32373 {
32374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32375 }
32376 return resultobj;
32377 fail:
32378 return NULL;
32379 }
32380
32381
32382 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32383 PyObject *obj;
32384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32385 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32386 return SWIG_Py_Void();
32387 }
32388
32389 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32390 return SWIG_Python_InitShadowInstance(args);
32391 }
32392
32393 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32394 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32395 return 1;
32396 }
32397
32398
32399 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32400 PyObject *pyobj = 0;
32401
32402 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32403 return pyobj;
32404 }
32405
32406
32407 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32408 PyObject *resultobj = 0;
32409 wxString *arg1 = 0 ;
32410 wxAcceleratorEntry *result = 0 ;
32411 bool temp1 = false ;
32412 PyObject * obj0 = 0 ;
32413 char * kwnames[] = {
32414 (char *) "label", NULL
32415 };
32416
32417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32418 {
32419 arg1 = wxString_in_helper(obj0);
32420 if (arg1 == NULL) SWIG_fail;
32421 temp1 = true;
32422 }
32423 {
32424 PyThreadState* __tstate = wxPyBeginAllowThreads();
32425 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32426 wxPyEndAllowThreads(__tstate);
32427 if (PyErr_Occurred()) SWIG_fail;
32428 }
32429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32430 {
32431 if (temp1)
32432 delete arg1;
32433 }
32434 return resultobj;
32435 fail:
32436 {
32437 if (temp1)
32438 delete arg1;
32439 }
32440 return NULL;
32441 }
32442
32443
32444 SWIGINTERN int PanelNameStr_set(PyObject *) {
32445 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32446 return 1;
32447 }
32448
32449
32450 SWIGINTERN PyObject *PanelNameStr_get(void) {
32451 PyObject *pyobj = 0;
32452
32453 {
32454 #if wxUSE_UNICODE
32455 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32456 #else
32457 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32458 #endif
32459 }
32460 return pyobj;
32461 }
32462
32463
32464 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32465 PyObject *resultobj = 0;
32466 wxVisualAttributes *result = 0 ;
32467
32468 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 result = (wxVisualAttributes *)new_wxVisualAttributes();
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32476 return resultobj;
32477 fail:
32478 return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32483 PyObject *resultobj = 0;
32484 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32485 void *argp1 = 0 ;
32486 int res1 = 0 ;
32487 PyObject *swig_obj[1] ;
32488
32489 if (!args) SWIG_fail;
32490 swig_obj[0] = args;
32491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32494 }
32495 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 delete_wxVisualAttributes(arg1);
32499
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 resultobj = SWIG_Py_Void();
32504 return resultobj;
32505 fail:
32506 return NULL;
32507 }
32508
32509
32510 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32511 PyObject *resultobj = 0;
32512 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32513 wxFont *arg2 = (wxFont *) 0 ;
32514 void *argp1 = 0 ;
32515 int res1 = 0 ;
32516 void *argp2 = 0 ;
32517 int res2 = 0 ;
32518 PyObject *swig_obj[2] ;
32519
32520 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32522 if (!SWIG_IsOK(res1)) {
32523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32524 }
32525 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32526 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32527 if (!SWIG_IsOK(res2)) {
32528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32529 }
32530 arg2 = reinterpret_cast< wxFont * >(argp2);
32531 if (arg1) (arg1)->font = *arg2;
32532
32533 resultobj = SWIG_Py_Void();
32534 return resultobj;
32535 fail:
32536 return NULL;
32537 }
32538
32539
32540 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32541 PyObject *resultobj = 0;
32542 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32543 wxFont *result = 0 ;
32544 void *argp1 = 0 ;
32545 int res1 = 0 ;
32546 PyObject *swig_obj[1] ;
32547
32548 if (!args) SWIG_fail;
32549 swig_obj[0] = args;
32550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32551 if (!SWIG_IsOK(res1)) {
32552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32553 }
32554 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32555 result = (wxFont *)& ((arg1)->font);
32556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32564 PyObject *resultobj = 0;
32565 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32566 wxColour *arg2 = (wxColour *) 0 ;
32567 void *argp1 = 0 ;
32568 int res1 = 0 ;
32569 void *argp2 = 0 ;
32570 int res2 = 0 ;
32571 PyObject *swig_obj[2] ;
32572
32573 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32575 if (!SWIG_IsOK(res1)) {
32576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32577 }
32578 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32579 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32580 if (!SWIG_IsOK(res2)) {
32581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32582 }
32583 arg2 = reinterpret_cast< wxColour * >(argp2);
32584 if (arg1) (arg1)->colFg = *arg2;
32585
32586 resultobj = SWIG_Py_Void();
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32594 PyObject *resultobj = 0;
32595 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32596 wxColour *result = 0 ;
32597 void *argp1 = 0 ;
32598 int res1 = 0 ;
32599 PyObject *swig_obj[1] ;
32600
32601 if (!args) SWIG_fail;
32602 swig_obj[0] = args;
32603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32604 if (!SWIG_IsOK(res1)) {
32605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32606 }
32607 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32608 result = (wxColour *)& ((arg1)->colFg);
32609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32610 return resultobj;
32611 fail:
32612 return NULL;
32613 }
32614
32615
32616 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32617 PyObject *resultobj = 0;
32618 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32619 wxColour *arg2 = (wxColour *) 0 ;
32620 void *argp1 = 0 ;
32621 int res1 = 0 ;
32622 void *argp2 = 0 ;
32623 int res2 = 0 ;
32624 PyObject *swig_obj[2] ;
32625
32626 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32628 if (!SWIG_IsOK(res1)) {
32629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32630 }
32631 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32632 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32633 if (!SWIG_IsOK(res2)) {
32634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32635 }
32636 arg2 = reinterpret_cast< wxColour * >(argp2);
32637 if (arg1) (arg1)->colBg = *arg2;
32638
32639 resultobj = SWIG_Py_Void();
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32647 PyObject *resultobj = 0;
32648 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32649 wxColour *result = 0 ;
32650 void *argp1 = 0 ;
32651 int res1 = 0 ;
32652 PyObject *swig_obj[1] ;
32653
32654 if (!args) SWIG_fail;
32655 swig_obj[0] = args;
32656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32657 if (!SWIG_IsOK(res1)) {
32658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32659 }
32660 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32661 result = (wxColour *)& ((arg1)->colBg);
32662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32663 return resultobj;
32664 fail:
32665 return NULL;
32666 }
32667
32668
32669 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32670 PyObject *obj;
32671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32672 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32673 return SWIG_Py_Void();
32674 }
32675
32676 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 return SWIG_Python_InitShadowInstance(args);
32678 }
32679
32680 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32681 PyObject *resultobj = 0;
32682 wxWindow *arg1 = (wxWindow *) 0 ;
32683 int arg2 = (int) (int)-1 ;
32684 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32685 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32686 wxSize const &arg4_defvalue = wxDefaultSize ;
32687 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32688 long arg5 = (long) 0 ;
32689 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32690 wxString *arg6 = (wxString *) &arg6_defvalue ;
32691 wxWindow *result = 0 ;
32692 void *argp1 = 0 ;
32693 int res1 = 0 ;
32694 int val2 ;
32695 int ecode2 = 0 ;
32696 wxPoint temp3 ;
32697 wxSize temp4 ;
32698 long val5 ;
32699 int ecode5 = 0 ;
32700 bool temp6 = false ;
32701 PyObject * obj0 = 0 ;
32702 PyObject * obj1 = 0 ;
32703 PyObject * obj2 = 0 ;
32704 PyObject * obj3 = 0 ;
32705 PyObject * obj4 = 0 ;
32706 PyObject * obj5 = 0 ;
32707 char * kwnames[] = {
32708 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32709 };
32710
32711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32713 if (!SWIG_IsOK(res1)) {
32714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32715 }
32716 arg1 = reinterpret_cast< wxWindow * >(argp1);
32717 if (obj1) {
32718 ecode2 = SWIG_AsVal_int(obj1, &val2);
32719 if (!SWIG_IsOK(ecode2)) {
32720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32721 }
32722 arg2 = static_cast< int >(val2);
32723 }
32724 if (obj2) {
32725 {
32726 arg3 = &temp3;
32727 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32728 }
32729 }
32730 if (obj3) {
32731 {
32732 arg4 = &temp4;
32733 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32734 }
32735 }
32736 if (obj4) {
32737 ecode5 = SWIG_AsVal_long(obj4, &val5);
32738 if (!SWIG_IsOK(ecode5)) {
32739 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32740 }
32741 arg5 = static_cast< long >(val5);
32742 }
32743 if (obj5) {
32744 {
32745 arg6 = wxString_in_helper(obj5);
32746 if (arg6 == NULL) SWIG_fail;
32747 temp6 = true;
32748 }
32749 }
32750 {
32751 if (!wxPyCheckForApp()) SWIG_fail;
32752 PyThreadState* __tstate = wxPyBeginAllowThreads();
32753 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32758 {
32759 if (temp6)
32760 delete arg6;
32761 }
32762 return resultobj;
32763 fail:
32764 {
32765 if (temp6)
32766 delete arg6;
32767 }
32768 return NULL;
32769 }
32770
32771
32772 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32773 PyObject *resultobj = 0;
32774 wxWindow *result = 0 ;
32775
32776 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32777 {
32778 if (!wxPyCheckForApp()) SWIG_fail;
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 result = (wxWindow *)new wxWindow();
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32785 return resultobj;
32786 fail:
32787 return NULL;
32788 }
32789
32790
32791 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32792 PyObject *resultobj = 0;
32793 wxWindow *arg1 = (wxWindow *) 0 ;
32794 wxWindow *arg2 = (wxWindow *) 0 ;
32795 int arg3 = (int) (int)-1 ;
32796 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32797 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32798 wxSize const &arg5_defvalue = wxDefaultSize ;
32799 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32800 long arg6 = (long) 0 ;
32801 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32802 wxString *arg7 = (wxString *) &arg7_defvalue ;
32803 bool result;
32804 void *argp1 = 0 ;
32805 int res1 = 0 ;
32806 void *argp2 = 0 ;
32807 int res2 = 0 ;
32808 int val3 ;
32809 int ecode3 = 0 ;
32810 wxPoint temp4 ;
32811 wxSize temp5 ;
32812 long val6 ;
32813 int ecode6 = 0 ;
32814 bool temp7 = false ;
32815 PyObject * obj0 = 0 ;
32816 PyObject * obj1 = 0 ;
32817 PyObject * obj2 = 0 ;
32818 PyObject * obj3 = 0 ;
32819 PyObject * obj4 = 0 ;
32820 PyObject * obj5 = 0 ;
32821 PyObject * obj6 = 0 ;
32822 char * kwnames[] = {
32823 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32824 };
32825
32826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32828 if (!SWIG_IsOK(res1)) {
32829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32830 }
32831 arg1 = reinterpret_cast< wxWindow * >(argp1);
32832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res2)) {
32834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32835 }
32836 arg2 = reinterpret_cast< wxWindow * >(argp2);
32837 if (obj2) {
32838 ecode3 = SWIG_AsVal_int(obj2, &val3);
32839 if (!SWIG_IsOK(ecode3)) {
32840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32841 }
32842 arg3 = static_cast< int >(val3);
32843 }
32844 if (obj3) {
32845 {
32846 arg4 = &temp4;
32847 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32848 }
32849 }
32850 if (obj4) {
32851 {
32852 arg5 = &temp5;
32853 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32854 }
32855 }
32856 if (obj5) {
32857 ecode6 = SWIG_AsVal_long(obj5, &val6);
32858 if (!SWIG_IsOK(ecode6)) {
32859 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32860 }
32861 arg6 = static_cast< long >(val6);
32862 }
32863 if (obj6) {
32864 {
32865 arg7 = wxString_in_helper(obj6);
32866 if (arg7 == NULL) SWIG_fail;
32867 temp7 = true;
32868 }
32869 }
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 {
32877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32878 }
32879 {
32880 if (temp7)
32881 delete arg7;
32882 }
32883 return resultobj;
32884 fail:
32885 {
32886 if (temp7)
32887 delete arg7;
32888 }
32889 return NULL;
32890 }
32891
32892
32893 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32894 PyObject *resultobj = 0;
32895 wxWindow *arg1 = (wxWindow *) 0 ;
32896 bool arg2 = (bool) false ;
32897 bool result;
32898 void *argp1 = 0 ;
32899 int res1 = 0 ;
32900 bool val2 ;
32901 int ecode2 = 0 ;
32902 PyObject * obj0 = 0 ;
32903 PyObject * obj1 = 0 ;
32904 char * kwnames[] = {
32905 (char *) "self",(char *) "force", NULL
32906 };
32907
32908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32910 if (!SWIG_IsOK(res1)) {
32911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32912 }
32913 arg1 = reinterpret_cast< wxWindow * >(argp1);
32914 if (obj1) {
32915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32916 if (!SWIG_IsOK(ecode2)) {
32917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32918 }
32919 arg2 = static_cast< bool >(val2);
32920 }
32921 {
32922 PyThreadState* __tstate = wxPyBeginAllowThreads();
32923 result = (bool)(arg1)->Close(arg2);
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 {
32928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32929 }
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32937 PyObject *resultobj = 0;
32938 wxWindow *arg1 = (wxWindow *) 0 ;
32939 bool result;
32940 void *argp1 = 0 ;
32941 int res1 = 0 ;
32942 PyObject *swig_obj[1] ;
32943
32944 if (!args) SWIG_fail;
32945 swig_obj[0] = args;
32946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 result = (bool)(arg1)->Destroy();
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 {
32958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32959 }
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 bool result;
32970 void *argp1 = 0 ;
32971 int res1 = 0 ;
32972 PyObject *swig_obj[1] ;
32973
32974 if (!args) SWIG_fail;
32975 swig_obj[0] = args;
32976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (bool)(arg1)->DestroyChildren();
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 {
32988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject *swig_obj[1] ;
33003
33004 if (!args) SWIG_fail;
33005 swig_obj[0] = args;
33006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 {
33018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33019 }
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33027 PyObject *resultobj = 0;
33028 wxWindow *arg1 = (wxWindow *) 0 ;
33029 wxString *arg2 = 0 ;
33030 void *argp1 = 0 ;
33031 int res1 = 0 ;
33032 bool temp2 = false ;
33033 PyObject * obj0 = 0 ;
33034 PyObject * obj1 = 0 ;
33035 char * kwnames[] = {
33036 (char *) "self",(char *) "label", NULL
33037 };
33038
33039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33041 if (!SWIG_IsOK(res1)) {
33042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33043 }
33044 arg1 = reinterpret_cast< wxWindow * >(argp1);
33045 {
33046 arg2 = wxString_in_helper(obj1);
33047 if (arg2 == NULL) SWIG_fail;
33048 temp2 = true;
33049 }
33050 {
33051 PyThreadState* __tstate = wxPyBeginAllowThreads();
33052 (arg1)->SetLabel((wxString const &)*arg2);
33053 wxPyEndAllowThreads(__tstate);
33054 if (PyErr_Occurred()) SWIG_fail;
33055 }
33056 resultobj = SWIG_Py_Void();
33057 {
33058 if (temp2)
33059 delete arg2;
33060 }
33061 return resultobj;
33062 fail:
33063 {
33064 if (temp2)
33065 delete arg2;
33066 }
33067 return NULL;
33068 }
33069
33070
33071 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33072 PyObject *resultobj = 0;
33073 wxWindow *arg1 = (wxWindow *) 0 ;
33074 wxString result;
33075 void *argp1 = 0 ;
33076 int res1 = 0 ;
33077 PyObject *swig_obj[1] ;
33078
33079 if (!args) SWIG_fail;
33080 swig_obj[0] = args;
33081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33082 if (!SWIG_IsOK(res1)) {
33083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33084 }
33085 arg1 = reinterpret_cast< wxWindow * >(argp1);
33086 {
33087 PyThreadState* __tstate = wxPyBeginAllowThreads();
33088 result = ((wxWindow const *)arg1)->GetLabel();
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 {
33093 #if wxUSE_UNICODE
33094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33095 #else
33096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33097 #endif
33098 }
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = 0;
33107 wxWindow *arg1 = (wxWindow *) 0 ;
33108 wxString *arg2 = 0 ;
33109 void *argp1 = 0 ;
33110 int res1 = 0 ;
33111 bool temp2 = false ;
33112 PyObject * obj0 = 0 ;
33113 PyObject * obj1 = 0 ;
33114 char * kwnames[] = {
33115 (char *) "self",(char *) "name", NULL
33116 };
33117
33118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33120 if (!SWIG_IsOK(res1)) {
33121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33122 }
33123 arg1 = reinterpret_cast< wxWindow * >(argp1);
33124 {
33125 arg2 = wxString_in_helper(obj1);
33126 if (arg2 == NULL) SWIG_fail;
33127 temp2 = true;
33128 }
33129 {
33130 PyThreadState* __tstate = wxPyBeginAllowThreads();
33131 (arg1)->SetName((wxString const &)*arg2);
33132 wxPyEndAllowThreads(__tstate);
33133 if (PyErr_Occurred()) SWIG_fail;
33134 }
33135 resultobj = SWIG_Py_Void();
33136 {
33137 if (temp2)
33138 delete arg2;
33139 }
33140 return resultobj;
33141 fail:
33142 {
33143 if (temp2)
33144 delete arg2;
33145 }
33146 return NULL;
33147 }
33148
33149
33150 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33151 PyObject *resultobj = 0;
33152 wxWindow *arg1 = (wxWindow *) 0 ;
33153 wxString result;
33154 void *argp1 = 0 ;
33155 int res1 = 0 ;
33156 PyObject *swig_obj[1] ;
33157
33158 if (!args) SWIG_fail;
33159 swig_obj[0] = args;
33160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33161 if (!SWIG_IsOK(res1)) {
33162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33163 }
33164 arg1 = reinterpret_cast< wxWindow * >(argp1);
33165 {
33166 PyThreadState* __tstate = wxPyBeginAllowThreads();
33167 result = ((wxWindow const *)arg1)->GetName();
33168 wxPyEndAllowThreads(__tstate);
33169 if (PyErr_Occurred()) SWIG_fail;
33170 }
33171 {
33172 #if wxUSE_UNICODE
33173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33174 #else
33175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33176 #endif
33177 }
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33185 PyObject *resultobj = 0;
33186 wxWindow *arg1 = (wxWindow *) 0 ;
33187 wxWindowVariant arg2 ;
33188 void *argp1 = 0 ;
33189 int res1 = 0 ;
33190 int val2 ;
33191 int ecode2 = 0 ;
33192 PyObject * obj0 = 0 ;
33193 PyObject * obj1 = 0 ;
33194 char * kwnames[] = {
33195 (char *) "self",(char *) "variant", NULL
33196 };
33197
33198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33200 if (!SWIG_IsOK(res1)) {
33201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33202 }
33203 arg1 = reinterpret_cast< wxWindow * >(argp1);
33204 ecode2 = SWIG_AsVal_int(obj1, &val2);
33205 if (!SWIG_IsOK(ecode2)) {
33206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33207 }
33208 arg2 = static_cast< wxWindowVariant >(val2);
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 (arg1)->SetWindowVariant(arg2);
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 resultobj = SWIG_Py_Void();
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33223 PyObject *resultobj = 0;
33224 wxWindow *arg1 = (wxWindow *) 0 ;
33225 wxWindowVariant result;
33226 void *argp1 = 0 ;
33227 int res1 = 0 ;
33228 PyObject *swig_obj[1] ;
33229
33230 if (!args) SWIG_fail;
33231 swig_obj[0] = args;
33232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33233 if (!SWIG_IsOK(res1)) {
33234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33235 }
33236 arg1 = reinterpret_cast< wxWindow * >(argp1);
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33240 wxPyEndAllowThreads(__tstate);
33241 if (PyErr_Occurred()) SWIG_fail;
33242 }
33243 resultobj = SWIG_From_int(static_cast< int >(result));
33244 return resultobj;
33245 fail:
33246 return NULL;
33247 }
33248
33249
33250 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33251 PyObject *resultobj = 0;
33252 wxWindow *arg1 = (wxWindow *) 0 ;
33253 int arg2 ;
33254 void *argp1 = 0 ;
33255 int res1 = 0 ;
33256 int val2 ;
33257 int ecode2 = 0 ;
33258 PyObject * obj0 = 0 ;
33259 PyObject * obj1 = 0 ;
33260 char * kwnames[] = {
33261 (char *) "self",(char *) "winid", NULL
33262 };
33263
33264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33266 if (!SWIG_IsOK(res1)) {
33267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33268 }
33269 arg1 = reinterpret_cast< wxWindow * >(argp1);
33270 ecode2 = SWIG_AsVal_int(obj1, &val2);
33271 if (!SWIG_IsOK(ecode2)) {
33272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33273 }
33274 arg2 = static_cast< int >(val2);
33275 {
33276 PyThreadState* __tstate = wxPyBeginAllowThreads();
33277 (arg1)->SetId(arg2);
33278 wxPyEndAllowThreads(__tstate);
33279 if (PyErr_Occurred()) SWIG_fail;
33280 }
33281 resultobj = SWIG_Py_Void();
33282 return resultobj;
33283 fail:
33284 return NULL;
33285 }
33286
33287
33288 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33289 PyObject *resultobj = 0;
33290 wxWindow *arg1 = (wxWindow *) 0 ;
33291 int result;
33292 void *argp1 = 0 ;
33293 int res1 = 0 ;
33294 PyObject *swig_obj[1] ;
33295
33296 if (!args) SWIG_fail;
33297 swig_obj[0] = args;
33298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33301 }
33302 arg1 = reinterpret_cast< wxWindow * >(argp1);
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 result = (int)((wxWindow const *)arg1)->GetId();
33306 wxPyEndAllowThreads(__tstate);
33307 if (PyErr_Occurred()) SWIG_fail;
33308 }
33309 resultobj = SWIG_From_int(static_cast< int >(result));
33310 return resultobj;
33311 fail:
33312 return NULL;
33313 }
33314
33315
33316 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33317 PyObject *resultobj = 0;
33318 int result;
33319
33320 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33321 {
33322 PyThreadState* __tstate = wxPyBeginAllowThreads();
33323 result = (int)wxWindow::NewControlId();
33324 wxPyEndAllowThreads(__tstate);
33325 if (PyErr_Occurred()) SWIG_fail;
33326 }
33327 resultobj = SWIG_From_int(static_cast< int >(result));
33328 return resultobj;
33329 fail:
33330 return NULL;
33331 }
33332
33333
33334 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33335 PyObject *resultobj = 0;
33336 int arg1 ;
33337 int result;
33338 int val1 ;
33339 int ecode1 = 0 ;
33340 PyObject * obj0 = 0 ;
33341 char * kwnames[] = {
33342 (char *) "winid", NULL
33343 };
33344
33345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33346 ecode1 = SWIG_AsVal_int(obj0, &val1);
33347 if (!SWIG_IsOK(ecode1)) {
33348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33349 }
33350 arg1 = static_cast< int >(val1);
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = (int)wxWindow::NextControlId(arg1);
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 resultobj = SWIG_From_int(static_cast< int >(result));
33358 return resultobj;
33359 fail:
33360 return NULL;
33361 }
33362
33363
33364 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33365 PyObject *resultobj = 0;
33366 int arg1 ;
33367 int result;
33368 int val1 ;
33369 int ecode1 = 0 ;
33370 PyObject * obj0 = 0 ;
33371 char * kwnames[] = {
33372 (char *) "winid", NULL
33373 };
33374
33375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33376 ecode1 = SWIG_AsVal_int(obj0, &val1);
33377 if (!SWIG_IsOK(ecode1)) {
33378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33379 }
33380 arg1 = static_cast< int >(val1);
33381 {
33382 PyThreadState* __tstate = wxPyBeginAllowThreads();
33383 result = (int)wxWindow::PrevControlId(arg1);
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 resultobj = SWIG_From_int(static_cast< int >(result));
33388 return resultobj;
33389 fail:
33390 return NULL;
33391 }
33392
33393
33394 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33395 PyObject *resultobj = 0;
33396 wxWindow *arg1 = (wxWindow *) 0 ;
33397 wxLayoutDirection result;
33398 void *argp1 = 0 ;
33399 int res1 = 0 ;
33400 PyObject *swig_obj[1] ;
33401
33402 if (!args) SWIG_fail;
33403 swig_obj[0] = args;
33404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33405 if (!SWIG_IsOK(res1)) {
33406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33407 }
33408 arg1 = reinterpret_cast< wxWindow * >(argp1);
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 resultobj = SWIG_From_int(static_cast< int >(result));
33416 return resultobj;
33417 fail:
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33423 PyObject *resultobj = 0;
33424 wxWindow *arg1 = (wxWindow *) 0 ;
33425 wxLayoutDirection arg2 ;
33426 void *argp1 = 0 ;
33427 int res1 = 0 ;
33428 int val2 ;
33429 int ecode2 = 0 ;
33430 PyObject * obj0 = 0 ;
33431 PyObject * obj1 = 0 ;
33432 char * kwnames[] = {
33433 (char *) "self",(char *) "dir", NULL
33434 };
33435
33436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33438 if (!SWIG_IsOK(res1)) {
33439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33440 }
33441 arg1 = reinterpret_cast< wxWindow * >(argp1);
33442 ecode2 = SWIG_AsVal_int(obj1, &val2);
33443 if (!SWIG_IsOK(ecode2)) {
33444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33445 }
33446 arg2 = static_cast< wxLayoutDirection >(val2);
33447 {
33448 PyThreadState* __tstate = wxPyBeginAllowThreads();
33449 (arg1)->SetLayoutDirection(arg2);
33450 wxPyEndAllowThreads(__tstate);
33451 if (PyErr_Occurred()) SWIG_fail;
33452 }
33453 resultobj = SWIG_Py_Void();
33454 return resultobj;
33455 fail:
33456 return NULL;
33457 }
33458
33459
33460 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33461 PyObject *resultobj = 0;
33462 wxWindow *arg1 = (wxWindow *) 0 ;
33463 int arg2 ;
33464 int arg3 ;
33465 int arg4 ;
33466 int result;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 int val2 ;
33470 int ecode2 = 0 ;
33471 int val3 ;
33472 int ecode3 = 0 ;
33473 int val4 ;
33474 int ecode4 = 0 ;
33475 PyObject * obj0 = 0 ;
33476 PyObject * obj1 = 0 ;
33477 PyObject * obj2 = 0 ;
33478 PyObject * obj3 = 0 ;
33479 char * kwnames[] = {
33480 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33481 };
33482
33483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33485 if (!SWIG_IsOK(res1)) {
33486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33487 }
33488 arg1 = reinterpret_cast< wxWindow * >(argp1);
33489 ecode2 = SWIG_AsVal_int(obj1, &val2);
33490 if (!SWIG_IsOK(ecode2)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33492 }
33493 arg2 = static_cast< int >(val2);
33494 ecode3 = SWIG_AsVal_int(obj2, &val3);
33495 if (!SWIG_IsOK(ecode3)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33497 }
33498 arg3 = static_cast< int >(val3);
33499 ecode4 = SWIG_AsVal_int(obj3, &val4);
33500 if (!SWIG_IsOK(ecode4)) {
33501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33502 }
33503 arg4 = static_cast< int >(val4);
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 resultobj = SWIG_From_int(static_cast< int >(result));
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33518 PyObject *resultobj = 0;
33519 wxWindow *arg1 = (wxWindow *) 0 ;
33520 wxSize *arg2 = 0 ;
33521 void *argp1 = 0 ;
33522 int res1 = 0 ;
33523 wxSize temp2 ;
33524 PyObject * obj0 = 0 ;
33525 PyObject * obj1 = 0 ;
33526 char * kwnames[] = {
33527 (char *) "self",(char *) "size", NULL
33528 };
33529
33530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33532 if (!SWIG_IsOK(res1)) {
33533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33534 }
33535 arg1 = reinterpret_cast< wxWindow * >(argp1);
33536 {
33537 arg2 = &temp2;
33538 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33539 }
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 (arg1)->SetSize((wxSize const &)*arg2);
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 resultobj = SWIG_Py_Void();
33547 return resultobj;
33548 fail:
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 int arg2 ;
33557 int arg3 ;
33558 int arg4 ;
33559 int arg5 ;
33560 int arg6 = (int) wxSIZE_AUTO ;
33561 void *argp1 = 0 ;
33562 int res1 = 0 ;
33563 int val2 ;
33564 int ecode2 = 0 ;
33565 int val3 ;
33566 int ecode3 = 0 ;
33567 int val4 ;
33568 int ecode4 = 0 ;
33569 int val5 ;
33570 int ecode5 = 0 ;
33571 int val6 ;
33572 int ecode6 = 0 ;
33573 PyObject * obj0 = 0 ;
33574 PyObject * obj1 = 0 ;
33575 PyObject * obj2 = 0 ;
33576 PyObject * obj3 = 0 ;
33577 PyObject * obj4 = 0 ;
33578 PyObject * obj5 = 0 ;
33579 char * kwnames[] = {
33580 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33581 };
33582
33583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33585 if (!SWIG_IsOK(res1)) {
33586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33587 }
33588 arg1 = reinterpret_cast< wxWindow * >(argp1);
33589 ecode2 = SWIG_AsVal_int(obj1, &val2);
33590 if (!SWIG_IsOK(ecode2)) {
33591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33592 }
33593 arg2 = static_cast< int >(val2);
33594 ecode3 = SWIG_AsVal_int(obj2, &val3);
33595 if (!SWIG_IsOK(ecode3)) {
33596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33597 }
33598 arg3 = static_cast< int >(val3);
33599 ecode4 = SWIG_AsVal_int(obj3, &val4);
33600 if (!SWIG_IsOK(ecode4)) {
33601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33602 }
33603 arg4 = static_cast< int >(val4);
33604 ecode5 = SWIG_AsVal_int(obj4, &val5);
33605 if (!SWIG_IsOK(ecode5)) {
33606 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33607 }
33608 arg5 = static_cast< int >(val5);
33609 if (obj5) {
33610 ecode6 = SWIG_AsVal_int(obj5, &val6);
33611 if (!SWIG_IsOK(ecode6)) {
33612 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33613 }
33614 arg6 = static_cast< int >(val6);
33615 }
33616 {
33617 PyThreadState* __tstate = wxPyBeginAllowThreads();
33618 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33619 wxPyEndAllowThreads(__tstate);
33620 if (PyErr_Occurred()) SWIG_fail;
33621 }
33622 resultobj = SWIG_Py_Void();
33623 return resultobj;
33624 fail:
33625 return NULL;
33626 }
33627
33628
33629 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33630 PyObject *resultobj = 0;
33631 wxWindow *arg1 = (wxWindow *) 0 ;
33632 wxRect *arg2 = 0 ;
33633 int arg3 = (int) wxSIZE_AUTO ;
33634 void *argp1 = 0 ;
33635 int res1 = 0 ;
33636 wxRect temp2 ;
33637 int val3 ;
33638 int ecode3 = 0 ;
33639 PyObject * obj0 = 0 ;
33640 PyObject * obj1 = 0 ;
33641 PyObject * obj2 = 0 ;
33642 char * kwnames[] = {
33643 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33644 };
33645
33646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33648 if (!SWIG_IsOK(res1)) {
33649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33650 }
33651 arg1 = reinterpret_cast< wxWindow * >(argp1);
33652 {
33653 arg2 = &temp2;
33654 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33655 }
33656 if (obj2) {
33657 ecode3 = SWIG_AsVal_int(obj2, &val3);
33658 if (!SWIG_IsOK(ecode3)) {
33659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33660 }
33661 arg3 = static_cast< int >(val3);
33662 }
33663 {
33664 PyThreadState* __tstate = wxPyBeginAllowThreads();
33665 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33666 wxPyEndAllowThreads(__tstate);
33667 if (PyErr_Occurred()) SWIG_fail;
33668 }
33669 resultobj = SWIG_Py_Void();
33670 return resultobj;
33671 fail:
33672 return NULL;
33673 }
33674
33675
33676 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33677 PyObject *resultobj = 0;
33678 wxWindow *arg1 = (wxWindow *) 0 ;
33679 int arg2 ;
33680 int arg3 ;
33681 void *argp1 = 0 ;
33682 int res1 = 0 ;
33683 int val2 ;
33684 int ecode2 = 0 ;
33685 int val3 ;
33686 int ecode3 = 0 ;
33687 PyObject * obj0 = 0 ;
33688 PyObject * obj1 = 0 ;
33689 PyObject * obj2 = 0 ;
33690 char * kwnames[] = {
33691 (char *) "self",(char *) "width",(char *) "height", NULL
33692 };
33693
33694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33696 if (!SWIG_IsOK(res1)) {
33697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33698 }
33699 arg1 = reinterpret_cast< wxWindow * >(argp1);
33700 ecode2 = SWIG_AsVal_int(obj1, &val2);
33701 if (!SWIG_IsOK(ecode2)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33703 }
33704 arg2 = static_cast< int >(val2);
33705 ecode3 = SWIG_AsVal_int(obj2, &val3);
33706 if (!SWIG_IsOK(ecode3)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33708 }
33709 arg3 = static_cast< int >(val3);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 (arg1)->SetSize(arg2,arg3);
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_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 wxPoint *arg2 = 0 ;
33727 int arg3 = (int) wxSIZE_USE_EXISTING ;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 wxPoint temp2 ;
33731 int val3 ;
33732 int ecode3 = 0 ;
33733 PyObject * obj0 = 0 ;
33734 PyObject * obj1 = 0 ;
33735 PyObject * obj2 = 0 ;
33736 char * kwnames[] = {
33737 (char *) "self",(char *) "pt",(char *) "flags", NULL
33738 };
33739
33740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33742 if (!SWIG_IsOK(res1)) {
33743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33744 }
33745 arg1 = reinterpret_cast< wxWindow * >(argp1);
33746 {
33747 arg2 = &temp2;
33748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33749 }
33750 if (obj2) {
33751 ecode3 = SWIG_AsVal_int(obj2, &val3);
33752 if (!SWIG_IsOK(ecode3)) {
33753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33754 }
33755 arg3 = static_cast< int >(val3);
33756 }
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 (arg1)->Move((wxPoint const &)*arg2,arg3);
33760 wxPyEndAllowThreads(__tstate);
33761 if (PyErr_Occurred()) SWIG_fail;
33762 }
33763 resultobj = SWIG_Py_Void();
33764 return resultobj;
33765 fail:
33766 return NULL;
33767 }
33768
33769
33770 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33771 PyObject *resultobj = 0;
33772 wxWindow *arg1 = (wxWindow *) 0 ;
33773 int arg2 ;
33774 int arg3 ;
33775 int arg4 = (int) wxSIZE_USE_EXISTING ;
33776 void *argp1 = 0 ;
33777 int res1 = 0 ;
33778 int val2 ;
33779 int ecode2 = 0 ;
33780 int val3 ;
33781 int ecode3 = 0 ;
33782 int val4 ;
33783 int ecode4 = 0 ;
33784 PyObject * obj0 = 0 ;
33785 PyObject * obj1 = 0 ;
33786 PyObject * obj2 = 0 ;
33787 PyObject * obj3 = 0 ;
33788 char * kwnames[] = {
33789 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33790 };
33791
33792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33794 if (!SWIG_IsOK(res1)) {
33795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33796 }
33797 arg1 = reinterpret_cast< wxWindow * >(argp1);
33798 ecode2 = SWIG_AsVal_int(obj1, &val2);
33799 if (!SWIG_IsOK(ecode2)) {
33800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33801 }
33802 arg2 = static_cast< int >(val2);
33803 ecode3 = SWIG_AsVal_int(obj2, &val3);
33804 if (!SWIG_IsOK(ecode3)) {
33805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33806 }
33807 arg3 = static_cast< int >(val3);
33808 if (obj3) {
33809 ecode4 = SWIG_AsVal_int(obj3, &val4);
33810 if (!SWIG_IsOK(ecode4)) {
33811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33812 }
33813 arg4 = static_cast< int >(val4);
33814 }
33815 {
33816 PyThreadState* __tstate = wxPyBeginAllowThreads();
33817 (arg1)->Move(arg2,arg3,arg4);
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 resultobj = SWIG_Py_Void();
33822 return resultobj;
33823 fail:
33824 return NULL;
33825 }
33826
33827
33828 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33829 PyObject *resultobj = 0;
33830 wxWindow *arg1 = (wxWindow *) 0 ;
33831 wxSize const &arg2_defvalue = wxDefaultSize ;
33832 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33833 void *argp1 = 0 ;
33834 int res1 = 0 ;
33835 wxSize temp2 ;
33836 PyObject * obj0 = 0 ;
33837 PyObject * obj1 = 0 ;
33838 char * kwnames[] = {
33839 (char *) "self",(char *) "size", NULL
33840 };
33841
33842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
33843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33844 if (!SWIG_IsOK(res1)) {
33845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33846 }
33847 arg1 = reinterpret_cast< wxWindow * >(argp1);
33848 if (obj1) {
33849 {
33850 arg2 = &temp2;
33851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33852 }
33853 }
33854 {
33855 PyThreadState* __tstate = wxPyBeginAllowThreads();
33856 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
33857 wxPyEndAllowThreads(__tstate);
33858 if (PyErr_Occurred()) SWIG_fail;
33859 }
33860 resultobj = SWIG_Py_Void();
33861 return resultobj;
33862 fail:
33863 return NULL;
33864 }
33865
33866
33867 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33868 PyObject *resultobj = 0;
33869 wxWindow *arg1 = (wxWindow *) 0 ;
33870 void *argp1 = 0 ;
33871 int res1 = 0 ;
33872 PyObject *swig_obj[1] ;
33873
33874 if (!args) SWIG_fail;
33875 swig_obj[0] = args;
33876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33877 if (!SWIG_IsOK(res1)) {
33878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33879 }
33880 arg1 = reinterpret_cast< wxWindow * >(argp1);
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 (arg1)->Raise();
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_Py_Void();
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33895 PyObject *resultobj = 0;
33896 wxWindow *arg1 = (wxWindow *) 0 ;
33897 void *argp1 = 0 ;
33898 int res1 = 0 ;
33899 PyObject *swig_obj[1] ;
33900
33901 if (!args) SWIG_fail;
33902 swig_obj[0] = args;
33903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33904 if (!SWIG_IsOK(res1)) {
33905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33906 }
33907 arg1 = reinterpret_cast< wxWindow * >(argp1);
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 (arg1)->Lower();
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 resultobj = SWIG_Py_Void();
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj = 0;
33923 wxWindow *arg1 = (wxWindow *) 0 ;
33924 wxSize *arg2 = 0 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 wxSize temp2 ;
33928 PyObject * obj0 = 0 ;
33929 PyObject * obj1 = 0 ;
33930 char * kwnames[] = {
33931 (char *) "self",(char *) "size", NULL
33932 };
33933
33934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33936 if (!SWIG_IsOK(res1)) {
33937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33938 }
33939 arg1 = reinterpret_cast< wxWindow * >(argp1);
33940 {
33941 arg2 = &temp2;
33942 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33943 }
33944 {
33945 PyThreadState* __tstate = wxPyBeginAllowThreads();
33946 (arg1)->SetClientSize((wxSize const &)*arg2);
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 resultobj = SWIG_Py_Void();
33951 return resultobj;
33952 fail:
33953 return NULL;
33954 }
33955
33956
33957 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33958 PyObject *resultobj = 0;
33959 wxWindow *arg1 = (wxWindow *) 0 ;
33960 int arg2 ;
33961 int arg3 ;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 int val2 ;
33965 int ecode2 = 0 ;
33966 int val3 ;
33967 int ecode3 = 0 ;
33968 PyObject * obj0 = 0 ;
33969 PyObject * obj1 = 0 ;
33970 PyObject * obj2 = 0 ;
33971 char * kwnames[] = {
33972 (char *) "self",(char *) "width",(char *) "height", NULL
33973 };
33974
33975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33979 }
33980 arg1 = reinterpret_cast< wxWindow * >(argp1);
33981 ecode2 = SWIG_AsVal_int(obj1, &val2);
33982 if (!SWIG_IsOK(ecode2)) {
33983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33984 }
33985 arg2 = static_cast< int >(val2);
33986 ecode3 = SWIG_AsVal_int(obj2, &val3);
33987 if (!SWIG_IsOK(ecode3)) {
33988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33989 }
33990 arg3 = static_cast< int >(val3);
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 (arg1)->SetClientSize(arg2,arg3);
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 resultobj = SWIG_Py_Void();
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj = 0;
34006 wxWindow *arg1 = (wxWindow *) 0 ;
34007 wxRect *arg2 = 0 ;
34008 void *argp1 = 0 ;
34009 int res1 = 0 ;
34010 wxRect temp2 ;
34011 PyObject * obj0 = 0 ;
34012 PyObject * obj1 = 0 ;
34013 char * kwnames[] = {
34014 (char *) "self",(char *) "rect", NULL
34015 };
34016
34017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34019 if (!SWIG_IsOK(res1)) {
34020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34021 }
34022 arg1 = reinterpret_cast< wxWindow * >(argp1);
34023 {
34024 arg2 = &temp2;
34025 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34026 }
34027 {
34028 PyThreadState* __tstate = wxPyBeginAllowThreads();
34029 (arg1)->SetClientSize((wxRect const &)*arg2);
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 resultobj = SWIG_Py_Void();
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34041 PyObject *resultobj = 0;
34042 wxWindow *arg1 = (wxWindow *) 0 ;
34043 wxPoint result;
34044 void *argp1 = 0 ;
34045 int res1 = 0 ;
34046 PyObject *swig_obj[1] ;
34047
34048 if (!args) SWIG_fail;
34049 swig_obj[0] = args;
34050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34051 if (!SWIG_IsOK(res1)) {
34052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34053 }
34054 arg1 = reinterpret_cast< wxWindow * >(argp1);
34055 {
34056 PyThreadState* __tstate = wxPyBeginAllowThreads();
34057 result = ((wxWindow const *)arg1)->GetPosition();
34058 wxPyEndAllowThreads(__tstate);
34059 if (PyErr_Occurred()) SWIG_fail;
34060 }
34061 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34069 PyObject *resultobj = 0;
34070 wxWindow *arg1 = (wxWindow *) 0 ;
34071 int *arg2 = (int *) 0 ;
34072 int *arg3 = (int *) 0 ;
34073 void *argp1 = 0 ;
34074 int res1 = 0 ;
34075 int temp2 ;
34076 int res2 = SWIG_TMPOBJ ;
34077 int temp3 ;
34078 int res3 = SWIG_TMPOBJ ;
34079 PyObject *swig_obj[1] ;
34080
34081 arg2 = &temp2;
34082 arg3 = &temp3;
34083 if (!args) SWIG_fail;
34084 swig_obj[0] = args;
34085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 {
34091 PyThreadState* __tstate = wxPyBeginAllowThreads();
34092 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34093 wxPyEndAllowThreads(__tstate);
34094 if (PyErr_Occurred()) SWIG_fail;
34095 }
34096 resultobj = SWIG_Py_Void();
34097 if (SWIG_IsTmpObj(res2)) {
34098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34099 } else {
34100 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34102 }
34103 if (SWIG_IsTmpObj(res3)) {
34104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34105 } else {
34106 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34108 }
34109 return resultobj;
34110 fail:
34111 return NULL;
34112 }
34113
34114
34115 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34116 PyObject *resultobj = 0;
34117 wxWindow *arg1 = (wxWindow *) 0 ;
34118 wxPoint result;
34119 void *argp1 = 0 ;
34120 int res1 = 0 ;
34121 PyObject *swig_obj[1] ;
34122
34123 if (!args) SWIG_fail;
34124 swig_obj[0] = args;
34125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34128 }
34129 arg1 = reinterpret_cast< wxWindow * >(argp1);
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = ((wxWindow const *)arg1)->GetScreenPosition();
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34144 PyObject *resultobj = 0;
34145 wxWindow *arg1 = (wxWindow *) 0 ;
34146 int *arg2 = (int *) 0 ;
34147 int *arg3 = (int *) 0 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 int temp2 ;
34151 int res2 = SWIG_TMPOBJ ;
34152 int temp3 ;
34153 int res3 = SWIG_TMPOBJ ;
34154 PyObject *swig_obj[1] ;
34155
34156 arg2 = &temp2;
34157 arg3 = &temp3;
34158 if (!args) SWIG_fail;
34159 swig_obj[0] = args;
34160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34161 if (!SWIG_IsOK(res1)) {
34162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34163 }
34164 arg1 = reinterpret_cast< wxWindow * >(argp1);
34165 {
34166 PyThreadState* __tstate = wxPyBeginAllowThreads();
34167 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34168 wxPyEndAllowThreads(__tstate);
34169 if (PyErr_Occurred()) SWIG_fail;
34170 }
34171 resultobj = SWIG_Py_Void();
34172 if (SWIG_IsTmpObj(res2)) {
34173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34174 } else {
34175 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34177 }
34178 if (SWIG_IsTmpObj(res3)) {
34179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34180 } else {
34181 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34183 }
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34191 PyObject *resultobj = 0;
34192 wxWindow *arg1 = (wxWindow *) 0 ;
34193 wxRect result;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 PyObject *swig_obj[1] ;
34197
34198 if (!args) SWIG_fail;
34199 swig_obj[0] = args;
34200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34203 }
34204 arg1 = reinterpret_cast< wxWindow * >(argp1);
34205 {
34206 PyThreadState* __tstate = wxPyBeginAllowThreads();
34207 result = ((wxWindow const *)arg1)->GetScreenRect();
34208 wxPyEndAllowThreads(__tstate);
34209 if (PyErr_Occurred()) SWIG_fail;
34210 }
34211 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34212 return resultobj;
34213 fail:
34214 return NULL;
34215 }
34216
34217
34218 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34219 PyObject *resultobj = 0;
34220 wxWindow *arg1 = (wxWindow *) 0 ;
34221 wxSize result;
34222 void *argp1 = 0 ;
34223 int res1 = 0 ;
34224 PyObject *swig_obj[1] ;
34225
34226 if (!args) SWIG_fail;
34227 swig_obj[0] = args;
34228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34229 if (!SWIG_IsOK(res1)) {
34230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34231 }
34232 arg1 = reinterpret_cast< wxWindow * >(argp1);
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 result = ((wxWindow const *)arg1)->GetSize();
34236 wxPyEndAllowThreads(__tstate);
34237 if (PyErr_Occurred()) SWIG_fail;
34238 }
34239 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34240 return resultobj;
34241 fail:
34242 return NULL;
34243 }
34244
34245
34246 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34247 PyObject *resultobj = 0;
34248 wxWindow *arg1 = (wxWindow *) 0 ;
34249 int *arg2 = (int *) 0 ;
34250 int *arg3 = (int *) 0 ;
34251 void *argp1 = 0 ;
34252 int res1 = 0 ;
34253 int temp2 ;
34254 int res2 = SWIG_TMPOBJ ;
34255 int temp3 ;
34256 int res3 = SWIG_TMPOBJ ;
34257 PyObject *swig_obj[1] ;
34258
34259 arg2 = &temp2;
34260 arg3 = &temp3;
34261 if (!args) SWIG_fail;
34262 swig_obj[0] = args;
34263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34266 }
34267 arg1 = reinterpret_cast< wxWindow * >(argp1);
34268 {
34269 PyThreadState* __tstate = wxPyBeginAllowThreads();
34270 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 resultobj = SWIG_Py_Void();
34275 if (SWIG_IsTmpObj(res2)) {
34276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34277 } else {
34278 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34280 }
34281 if (SWIG_IsTmpObj(res3)) {
34282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34283 } else {
34284 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34286 }
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34294 PyObject *resultobj = 0;
34295 wxWindow *arg1 = (wxWindow *) 0 ;
34296 wxRect result;
34297 void *argp1 = 0 ;
34298 int res1 = 0 ;
34299 PyObject *swig_obj[1] ;
34300
34301 if (!args) SWIG_fail;
34302 swig_obj[0] = args;
34303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34304 if (!SWIG_IsOK(res1)) {
34305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34306 }
34307 arg1 = reinterpret_cast< wxWindow * >(argp1);
34308 {
34309 PyThreadState* __tstate = wxPyBeginAllowThreads();
34310 result = ((wxWindow const *)arg1)->GetRect();
34311 wxPyEndAllowThreads(__tstate);
34312 if (PyErr_Occurred()) SWIG_fail;
34313 }
34314 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34315 return resultobj;
34316 fail:
34317 return NULL;
34318 }
34319
34320
34321 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34322 PyObject *resultobj = 0;
34323 wxWindow *arg1 = (wxWindow *) 0 ;
34324 wxSize result;
34325 void *argp1 = 0 ;
34326 int res1 = 0 ;
34327 PyObject *swig_obj[1] ;
34328
34329 if (!args) SWIG_fail;
34330 swig_obj[0] = args;
34331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34332 if (!SWIG_IsOK(res1)) {
34333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34334 }
34335 arg1 = reinterpret_cast< wxWindow * >(argp1);
34336 {
34337 PyThreadState* __tstate = wxPyBeginAllowThreads();
34338 result = ((wxWindow const *)arg1)->GetClientSize();
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34343 return resultobj;
34344 fail:
34345 return NULL;
34346 }
34347
34348
34349 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34350 PyObject *resultobj = 0;
34351 wxWindow *arg1 = (wxWindow *) 0 ;
34352 int *arg2 = (int *) 0 ;
34353 int *arg3 = (int *) 0 ;
34354 void *argp1 = 0 ;
34355 int res1 = 0 ;
34356 int temp2 ;
34357 int res2 = SWIG_TMPOBJ ;
34358 int temp3 ;
34359 int res3 = SWIG_TMPOBJ ;
34360 PyObject *swig_obj[1] ;
34361
34362 arg2 = &temp2;
34363 arg3 = &temp3;
34364 if (!args) SWIG_fail;
34365 swig_obj[0] = args;
34366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34367 if (!SWIG_IsOK(res1)) {
34368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34369 }
34370 arg1 = reinterpret_cast< wxWindow * >(argp1);
34371 {
34372 PyThreadState* __tstate = wxPyBeginAllowThreads();
34373 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 resultobj = SWIG_Py_Void();
34378 if (SWIG_IsTmpObj(res2)) {
34379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34380 } else {
34381 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34383 }
34384 if (SWIG_IsTmpObj(res3)) {
34385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34386 } else {
34387 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34389 }
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34397 PyObject *resultobj = 0;
34398 wxWindow *arg1 = (wxWindow *) 0 ;
34399 wxPoint result;
34400 void *argp1 = 0 ;
34401 int res1 = 0 ;
34402 PyObject *swig_obj[1] ;
34403
34404 if (!args) SWIG_fail;
34405 swig_obj[0] = args;
34406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34407 if (!SWIG_IsOK(res1)) {
34408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34409 }
34410 arg1 = reinterpret_cast< wxWindow * >(argp1);
34411 {
34412 PyThreadState* __tstate = wxPyBeginAllowThreads();
34413 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34414 wxPyEndAllowThreads(__tstate);
34415 if (PyErr_Occurred()) SWIG_fail;
34416 }
34417 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34418 return resultobj;
34419 fail:
34420 return NULL;
34421 }
34422
34423
34424 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34425 PyObject *resultobj = 0;
34426 wxWindow *arg1 = (wxWindow *) 0 ;
34427 wxRect result;
34428 void *argp1 = 0 ;
34429 int res1 = 0 ;
34430 PyObject *swig_obj[1] ;
34431
34432 if (!args) SWIG_fail;
34433 swig_obj[0] = args;
34434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34435 if (!SWIG_IsOK(res1)) {
34436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34437 }
34438 arg1 = reinterpret_cast< wxWindow * >(argp1);
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 result = ((wxWindow const *)arg1)->GetClientRect();
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34453 PyObject *resultobj = 0;
34454 wxWindow *arg1 = (wxWindow *) 0 ;
34455 wxSize result;
34456 void *argp1 = 0 ;
34457 int res1 = 0 ;
34458 PyObject *swig_obj[1] ;
34459
34460 if (!args) SWIG_fail;
34461 swig_obj[0] = args;
34462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34463 if (!SWIG_IsOK(res1)) {
34464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34465 }
34466 arg1 = reinterpret_cast< wxWindow * >(argp1);
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 result = ((wxWindow const *)arg1)->GetBestSize();
34470 wxPyEndAllowThreads(__tstate);
34471 if (PyErr_Occurred()) SWIG_fail;
34472 }
34473 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34481 PyObject *resultobj = 0;
34482 wxWindow *arg1 = (wxWindow *) 0 ;
34483 int *arg2 = (int *) 0 ;
34484 int *arg3 = (int *) 0 ;
34485 void *argp1 = 0 ;
34486 int res1 = 0 ;
34487 int temp2 ;
34488 int res2 = SWIG_TMPOBJ ;
34489 int temp3 ;
34490 int res3 = SWIG_TMPOBJ ;
34491 PyObject *swig_obj[1] ;
34492
34493 arg2 = &temp2;
34494 arg3 = &temp3;
34495 if (!args) SWIG_fail;
34496 swig_obj[0] = args;
34497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34498 if (!SWIG_IsOK(res1)) {
34499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34500 }
34501 arg1 = reinterpret_cast< wxWindow * >(argp1);
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 resultobj = SWIG_Py_Void();
34509 if (SWIG_IsTmpObj(res2)) {
34510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34511 } else {
34512 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34514 }
34515 if (SWIG_IsTmpObj(res3)) {
34516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34517 } else {
34518 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34520 }
34521 return resultobj;
34522 fail:
34523 return NULL;
34524 }
34525
34526
34527 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34528 PyObject *resultobj = 0;
34529 wxWindow *arg1 = (wxWindow *) 0 ;
34530 void *argp1 = 0 ;
34531 int res1 = 0 ;
34532 PyObject *swig_obj[1] ;
34533
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_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34539 }
34540 arg1 = reinterpret_cast< wxWindow * >(argp1);
34541 {
34542 PyThreadState* __tstate = wxPyBeginAllowThreads();
34543 (arg1)->InvalidateBestSize();
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 resultobj = SWIG_Py_Void();
34548 return resultobj;
34549 fail:
34550 return NULL;
34551 }
34552
34553
34554 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34555 PyObject *resultobj = 0;
34556 wxWindow *arg1 = (wxWindow *) 0 ;
34557 wxSize *arg2 = 0 ;
34558 void *argp1 = 0 ;
34559 int res1 = 0 ;
34560 wxSize temp2 ;
34561 PyObject * obj0 = 0 ;
34562 PyObject * obj1 = 0 ;
34563 char * kwnames[] = {
34564 (char *) "self",(char *) "size", NULL
34565 };
34566
34567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34569 if (!SWIG_IsOK(res1)) {
34570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34571 }
34572 arg1 = reinterpret_cast< wxWindow * >(argp1);
34573 {
34574 arg2 = &temp2;
34575 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34576 }
34577 {
34578 PyThreadState* __tstate = wxPyBeginAllowThreads();
34579 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34580 wxPyEndAllowThreads(__tstate);
34581 if (PyErr_Occurred()) SWIG_fail;
34582 }
34583 resultobj = SWIG_Py_Void();
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34591 PyObject *resultobj = 0;
34592 wxWindow *arg1 = (wxWindow *) 0 ;
34593 wxSize result;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 PyObject *swig_obj[1] ;
34597
34598 if (!args) SWIG_fail;
34599 swig_obj[0] = args;
34600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34601 if (!SWIG_IsOK(res1)) {
34602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34603 }
34604 arg1 = reinterpret_cast< wxWindow * >(argp1);
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 result = ((wxWindow const *)arg1)->GetBestFittingSize();
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34612 return resultobj;
34613 fail:
34614 return NULL;
34615 }
34616
34617
34618 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34619 PyObject *resultobj = 0;
34620 wxWindow *arg1 = (wxWindow *) 0 ;
34621 wxSize result;
34622 void *argp1 = 0 ;
34623 int res1 = 0 ;
34624 PyObject *swig_obj[1] ;
34625
34626 if (!args) SWIG_fail;
34627 swig_obj[0] = args;
34628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34629 if (!SWIG_IsOK(res1)) {
34630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34631 }
34632 arg1 = reinterpret_cast< wxWindow * >(argp1);
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34647 PyObject *resultobj = 0;
34648 wxWindow *arg1 = (wxWindow *) 0 ;
34649 int arg2 = (int) wxBOTH ;
34650 void *argp1 = 0 ;
34651 int res1 = 0 ;
34652 int val2 ;
34653 int ecode2 = 0 ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 char * kwnames[] = {
34657 (char *) "self",(char *) "direction", NULL
34658 };
34659
34660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34664 }
34665 arg1 = reinterpret_cast< wxWindow * >(argp1);
34666 if (obj1) {
34667 ecode2 = SWIG_AsVal_int(obj1, &val2);
34668 if (!SWIG_IsOK(ecode2)) {
34669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34670 }
34671 arg2 = static_cast< int >(val2);
34672 }
34673 {
34674 PyThreadState* __tstate = wxPyBeginAllowThreads();
34675 (arg1)->Center(arg2);
34676 wxPyEndAllowThreads(__tstate);
34677 if (PyErr_Occurred()) SWIG_fail;
34678 }
34679 resultobj = SWIG_Py_Void();
34680 return resultobj;
34681 fail:
34682 return NULL;
34683 }
34684
34685
34686 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34687 PyObject *resultobj = 0;
34688 wxWindow *arg1 = (wxWindow *) 0 ;
34689 int arg2 = (int) wxBOTH ;
34690 void *argp1 = 0 ;
34691 int res1 = 0 ;
34692 int val2 ;
34693 int ecode2 = 0 ;
34694 PyObject * obj0 = 0 ;
34695 PyObject * obj1 = 0 ;
34696 char * kwnames[] = {
34697 (char *) "self",(char *) "dir", NULL
34698 };
34699
34700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34702 if (!SWIG_IsOK(res1)) {
34703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34704 }
34705 arg1 = reinterpret_cast< wxWindow * >(argp1);
34706 if (obj1) {
34707 ecode2 = SWIG_AsVal_int(obj1, &val2);
34708 if (!SWIG_IsOK(ecode2)) {
34709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34710 }
34711 arg2 = static_cast< int >(val2);
34712 }
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 (arg1)->CenterOnParent(arg2);
34716 wxPyEndAllowThreads(__tstate);
34717 if (PyErr_Occurred()) SWIG_fail;
34718 }
34719 resultobj = SWIG_Py_Void();
34720 return resultobj;
34721 fail:
34722 return NULL;
34723 }
34724
34725
34726 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34727 PyObject *resultobj = 0;
34728 wxWindow *arg1 = (wxWindow *) 0 ;
34729 void *argp1 = 0 ;
34730 int res1 = 0 ;
34731 PyObject *swig_obj[1] ;
34732
34733 if (!args) SWIG_fail;
34734 swig_obj[0] = args;
34735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34736 if (!SWIG_IsOK(res1)) {
34737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34738 }
34739 arg1 = reinterpret_cast< wxWindow * >(argp1);
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 (arg1)->Fit();
34743 wxPyEndAllowThreads(__tstate);
34744 if (PyErr_Occurred()) SWIG_fail;
34745 }
34746 resultobj = SWIG_Py_Void();
34747 return resultobj;
34748 fail:
34749 return NULL;
34750 }
34751
34752
34753 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34754 PyObject *resultobj = 0;
34755 wxWindow *arg1 = (wxWindow *) 0 ;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 PyObject *swig_obj[1] ;
34759
34760 if (!args) SWIG_fail;
34761 swig_obj[0] = args;
34762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34765 }
34766 arg1 = reinterpret_cast< wxWindow * >(argp1);
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 (arg1)->FitInside();
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 resultobj = SWIG_Py_Void();
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34781 PyObject *resultobj = 0;
34782 wxWindow *arg1 = (wxWindow *) 0 ;
34783 int arg2 ;
34784 int arg3 ;
34785 int arg4 = (int) -1 ;
34786 int arg5 = (int) -1 ;
34787 int arg6 = (int) -1 ;
34788 int arg7 = (int) -1 ;
34789 void *argp1 = 0 ;
34790 int res1 = 0 ;
34791 int val2 ;
34792 int ecode2 = 0 ;
34793 int val3 ;
34794 int ecode3 = 0 ;
34795 int val4 ;
34796 int ecode4 = 0 ;
34797 int val5 ;
34798 int ecode5 = 0 ;
34799 int val6 ;
34800 int ecode6 = 0 ;
34801 int val7 ;
34802 int ecode7 = 0 ;
34803 PyObject * obj0 = 0 ;
34804 PyObject * obj1 = 0 ;
34805 PyObject * obj2 = 0 ;
34806 PyObject * obj3 = 0 ;
34807 PyObject * obj4 = 0 ;
34808 PyObject * obj5 = 0 ;
34809 PyObject * obj6 = 0 ;
34810 char * kwnames[] = {
34811 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34812 };
34813
34814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34816 if (!SWIG_IsOK(res1)) {
34817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34818 }
34819 arg1 = reinterpret_cast< wxWindow * >(argp1);
34820 ecode2 = SWIG_AsVal_int(obj1, &val2);
34821 if (!SWIG_IsOK(ecode2)) {
34822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34823 }
34824 arg2 = static_cast< int >(val2);
34825 ecode3 = SWIG_AsVal_int(obj2, &val3);
34826 if (!SWIG_IsOK(ecode3)) {
34827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34828 }
34829 arg3 = static_cast< int >(val3);
34830 if (obj3) {
34831 ecode4 = SWIG_AsVal_int(obj3, &val4);
34832 if (!SWIG_IsOK(ecode4)) {
34833 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34834 }
34835 arg4 = static_cast< int >(val4);
34836 }
34837 if (obj4) {
34838 ecode5 = SWIG_AsVal_int(obj4, &val5);
34839 if (!SWIG_IsOK(ecode5)) {
34840 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34841 }
34842 arg5 = static_cast< int >(val5);
34843 }
34844 if (obj5) {
34845 ecode6 = SWIG_AsVal_int(obj5, &val6);
34846 if (!SWIG_IsOK(ecode6)) {
34847 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34848 }
34849 arg6 = static_cast< int >(val6);
34850 }
34851 if (obj6) {
34852 ecode7 = SWIG_AsVal_int(obj6, &val7);
34853 if (!SWIG_IsOK(ecode7)) {
34854 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34855 }
34856 arg7 = static_cast< int >(val7);
34857 }
34858 {
34859 PyThreadState* __tstate = wxPyBeginAllowThreads();
34860 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 resultobj = SWIG_Py_Void();
34865 return resultobj;
34866 fail:
34867 return NULL;
34868 }
34869
34870
34871 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34872 PyObject *resultobj = 0;
34873 wxWindow *arg1 = (wxWindow *) 0 ;
34874 wxSize *arg2 = 0 ;
34875 wxSize const &arg3_defvalue = wxDefaultSize ;
34876 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34877 wxSize const &arg4_defvalue = wxDefaultSize ;
34878 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34879 void *argp1 = 0 ;
34880 int res1 = 0 ;
34881 wxSize temp2 ;
34882 wxSize temp3 ;
34883 wxSize temp4 ;
34884 PyObject * obj0 = 0 ;
34885 PyObject * obj1 = 0 ;
34886 PyObject * obj2 = 0 ;
34887 PyObject * obj3 = 0 ;
34888 char * kwnames[] = {
34889 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34890 };
34891
34892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34894 if (!SWIG_IsOK(res1)) {
34895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34896 }
34897 arg1 = reinterpret_cast< wxWindow * >(argp1);
34898 {
34899 arg2 = &temp2;
34900 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34901 }
34902 if (obj2) {
34903 {
34904 arg3 = &temp3;
34905 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34906 }
34907 }
34908 if (obj3) {
34909 {
34910 arg4 = &temp4;
34911 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34912 }
34913 }
34914 {
34915 PyThreadState* __tstate = wxPyBeginAllowThreads();
34916 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34917 wxPyEndAllowThreads(__tstate);
34918 if (PyErr_Occurred()) SWIG_fail;
34919 }
34920 resultobj = SWIG_Py_Void();
34921 return resultobj;
34922 fail:
34923 return NULL;
34924 }
34925
34926
34927 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34928 PyObject *resultobj = 0;
34929 wxWindow *arg1 = (wxWindow *) 0 ;
34930 int arg2 ;
34931 int arg3 ;
34932 int arg4 = (int) -1 ;
34933 int arg5 = (int) -1 ;
34934 void *argp1 = 0 ;
34935 int res1 = 0 ;
34936 int val2 ;
34937 int ecode2 = 0 ;
34938 int val3 ;
34939 int ecode3 = 0 ;
34940 int val4 ;
34941 int ecode4 = 0 ;
34942 int val5 ;
34943 int ecode5 = 0 ;
34944 PyObject * obj0 = 0 ;
34945 PyObject * obj1 = 0 ;
34946 PyObject * obj2 = 0 ;
34947 PyObject * obj3 = 0 ;
34948 PyObject * obj4 = 0 ;
34949 char * kwnames[] = {
34950 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34951 };
34952
34953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34955 if (!SWIG_IsOK(res1)) {
34956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34957 }
34958 arg1 = reinterpret_cast< wxWindow * >(argp1);
34959 ecode2 = SWIG_AsVal_int(obj1, &val2);
34960 if (!SWIG_IsOK(ecode2)) {
34961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34962 }
34963 arg2 = static_cast< int >(val2);
34964 ecode3 = SWIG_AsVal_int(obj2, &val3);
34965 if (!SWIG_IsOK(ecode3)) {
34966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34967 }
34968 arg3 = static_cast< int >(val3);
34969 if (obj3) {
34970 ecode4 = SWIG_AsVal_int(obj3, &val4);
34971 if (!SWIG_IsOK(ecode4)) {
34972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34973 }
34974 arg4 = static_cast< int >(val4);
34975 }
34976 if (obj4) {
34977 ecode5 = SWIG_AsVal_int(obj4, &val5);
34978 if (!SWIG_IsOK(ecode5)) {
34979 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34980 }
34981 arg5 = static_cast< int >(val5);
34982 }
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34986 wxPyEndAllowThreads(__tstate);
34987 if (PyErr_Occurred()) SWIG_fail;
34988 }
34989 resultobj = SWIG_Py_Void();
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34997 PyObject *resultobj = 0;
34998 wxWindow *arg1 = (wxWindow *) 0 ;
34999 wxSize *arg2 = 0 ;
35000 wxSize const &arg3_defvalue = wxDefaultSize ;
35001 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35002 void *argp1 = 0 ;
35003 int res1 = 0 ;
35004 wxSize temp2 ;
35005 wxSize temp3 ;
35006 PyObject * obj0 = 0 ;
35007 PyObject * obj1 = 0 ;
35008 PyObject * obj2 = 0 ;
35009 char * kwnames[] = {
35010 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35011 };
35012
35013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 arg2 = &temp2;
35021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35022 }
35023 if (obj2) {
35024 {
35025 arg3 = &temp3;
35026 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35027 }
35028 }
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 resultobj = SWIG_Py_Void();
35036 return resultobj;
35037 fail:
35038 return NULL;
35039 }
35040
35041
35042 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35043 PyObject *resultobj = 0;
35044 wxWindow *arg1 = (wxWindow *) 0 ;
35045 wxSize result;
35046 void *argp1 = 0 ;
35047 int res1 = 0 ;
35048 PyObject *swig_obj[1] ;
35049
35050 if (!args) SWIG_fail;
35051 swig_obj[0] = args;
35052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35053 if (!SWIG_IsOK(res1)) {
35054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35055 }
35056 arg1 = reinterpret_cast< wxWindow * >(argp1);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = ((wxWindow const *)arg1)->GetMaxSize();
35060 wxPyEndAllowThreads(__tstate);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 }
35063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35064 return resultobj;
35065 fail:
35066 return NULL;
35067 }
35068
35069
35070 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35071 PyObject *resultobj = 0;
35072 wxWindow *arg1 = (wxWindow *) 0 ;
35073 wxSize result;
35074 void *argp1 = 0 ;
35075 int res1 = 0 ;
35076 PyObject *swig_obj[1] ;
35077
35078 if (!args) SWIG_fail;
35079 swig_obj[0] = args;
35080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35081 if (!SWIG_IsOK(res1)) {
35082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35083 }
35084 arg1 = reinterpret_cast< wxWindow * >(argp1);
35085 {
35086 PyThreadState* __tstate = wxPyBeginAllowThreads();
35087 result = ((wxWindow const *)arg1)->GetMinSize();
35088 wxPyEndAllowThreads(__tstate);
35089 if (PyErr_Occurred()) SWIG_fail;
35090 }
35091 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj = 0;
35100 wxWindow *arg1 = (wxWindow *) 0 ;
35101 wxSize *arg2 = 0 ;
35102 void *argp1 = 0 ;
35103 int res1 = 0 ;
35104 wxSize temp2 ;
35105 PyObject * obj0 = 0 ;
35106 PyObject * obj1 = 0 ;
35107 char * kwnames[] = {
35108 (char *) "self",(char *) "minSize", NULL
35109 };
35110
35111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 {
35118 arg2 = &temp2;
35119 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35120 }
35121 {
35122 PyThreadState* __tstate = wxPyBeginAllowThreads();
35123 (arg1)->SetMinSize((wxSize const &)*arg2);
35124 wxPyEndAllowThreads(__tstate);
35125 if (PyErr_Occurred()) SWIG_fail;
35126 }
35127 resultobj = SWIG_Py_Void();
35128 return resultobj;
35129 fail:
35130 return NULL;
35131 }
35132
35133
35134 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35135 PyObject *resultobj = 0;
35136 wxWindow *arg1 = (wxWindow *) 0 ;
35137 wxSize *arg2 = 0 ;
35138 void *argp1 = 0 ;
35139 int res1 = 0 ;
35140 wxSize temp2 ;
35141 PyObject * obj0 = 0 ;
35142 PyObject * obj1 = 0 ;
35143 char * kwnames[] = {
35144 (char *) "self",(char *) "maxSize", NULL
35145 };
35146
35147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35149 if (!SWIG_IsOK(res1)) {
35150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35151 }
35152 arg1 = reinterpret_cast< wxWindow * >(argp1);
35153 {
35154 arg2 = &temp2;
35155 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35156 }
35157 {
35158 PyThreadState* __tstate = wxPyBeginAllowThreads();
35159 (arg1)->SetMaxSize((wxSize const &)*arg2);
35160 wxPyEndAllowThreads(__tstate);
35161 if (PyErr_Occurred()) SWIG_fail;
35162 }
35163 resultobj = SWIG_Py_Void();
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35171 PyObject *resultobj = 0;
35172 wxWindow *arg1 = (wxWindow *) 0 ;
35173 int result;
35174 void *argp1 = 0 ;
35175 int res1 = 0 ;
35176 PyObject *swig_obj[1] ;
35177
35178 if (!args) SWIG_fail;
35179 swig_obj[0] = args;
35180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35181 if (!SWIG_IsOK(res1)) {
35182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35183 }
35184 arg1 = reinterpret_cast< wxWindow * >(argp1);
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 resultobj = SWIG_From_int(static_cast< int >(result));
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35199 PyObject *resultobj = 0;
35200 wxWindow *arg1 = (wxWindow *) 0 ;
35201 int result;
35202 void *argp1 = 0 ;
35203 int res1 = 0 ;
35204 PyObject *swig_obj[1] ;
35205
35206 if (!args) SWIG_fail;
35207 swig_obj[0] = args;
35208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35209 if (!SWIG_IsOK(res1)) {
35210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35211 }
35212 arg1 = reinterpret_cast< wxWindow * >(argp1);
35213 {
35214 PyThreadState* __tstate = wxPyBeginAllowThreads();
35215 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35216 wxPyEndAllowThreads(__tstate);
35217 if (PyErr_Occurred()) SWIG_fail;
35218 }
35219 resultobj = SWIG_From_int(static_cast< int >(result));
35220 return resultobj;
35221 fail:
35222 return NULL;
35223 }
35224
35225
35226 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35227 PyObject *resultobj = 0;
35228 wxWindow *arg1 = (wxWindow *) 0 ;
35229 int result;
35230 void *argp1 = 0 ;
35231 int res1 = 0 ;
35232 PyObject *swig_obj[1] ;
35233
35234 if (!args) SWIG_fail;
35235 swig_obj[0] = args;
35236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35239 }
35240 arg1 = reinterpret_cast< wxWindow * >(argp1);
35241 {
35242 PyThreadState* __tstate = wxPyBeginAllowThreads();
35243 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35244 wxPyEndAllowThreads(__tstate);
35245 if (PyErr_Occurred()) SWIG_fail;
35246 }
35247 resultobj = SWIG_From_int(static_cast< int >(result));
35248 return resultobj;
35249 fail:
35250 return NULL;
35251 }
35252
35253
35254 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35255 PyObject *resultobj = 0;
35256 wxWindow *arg1 = (wxWindow *) 0 ;
35257 int result;
35258 void *argp1 = 0 ;
35259 int res1 = 0 ;
35260 PyObject *swig_obj[1] ;
35261
35262 if (!args) SWIG_fail;
35263 swig_obj[0] = args;
35264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35265 if (!SWIG_IsOK(res1)) {
35266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35267 }
35268 arg1 = reinterpret_cast< wxWindow * >(argp1);
35269 {
35270 PyThreadState* __tstate = wxPyBeginAllowThreads();
35271 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35272 wxPyEndAllowThreads(__tstate);
35273 if (PyErr_Occurred()) SWIG_fail;
35274 }
35275 resultobj = SWIG_From_int(static_cast< int >(result));
35276 return resultobj;
35277 fail:
35278 return NULL;
35279 }
35280
35281
35282 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35283 PyObject *resultobj = 0;
35284 wxWindow *arg1 = (wxWindow *) 0 ;
35285 wxSize *arg2 = 0 ;
35286 void *argp1 = 0 ;
35287 int res1 = 0 ;
35288 wxSize temp2 ;
35289 PyObject * obj0 = 0 ;
35290 PyObject * obj1 = 0 ;
35291 char * kwnames[] = {
35292 (char *) "self",(char *) "size", NULL
35293 };
35294
35295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35299 }
35300 arg1 = reinterpret_cast< wxWindow * >(argp1);
35301 {
35302 arg2 = &temp2;
35303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35304 }
35305 {
35306 PyThreadState* __tstate = wxPyBeginAllowThreads();
35307 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 resultobj = SWIG_Py_Void();
35312 return resultobj;
35313 fail:
35314 return NULL;
35315 }
35316
35317
35318 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35319 PyObject *resultobj = 0;
35320 wxWindow *arg1 = (wxWindow *) 0 ;
35321 int arg2 ;
35322 int arg3 ;
35323 void *argp1 = 0 ;
35324 int res1 = 0 ;
35325 int val2 ;
35326 int ecode2 = 0 ;
35327 int val3 ;
35328 int ecode3 = 0 ;
35329 PyObject * obj0 = 0 ;
35330 PyObject * obj1 = 0 ;
35331 PyObject * obj2 = 0 ;
35332 char * kwnames[] = {
35333 (char *) "self",(char *) "w",(char *) "h", NULL
35334 };
35335
35336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35338 if (!SWIG_IsOK(res1)) {
35339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35340 }
35341 arg1 = reinterpret_cast< wxWindow * >(argp1);
35342 ecode2 = SWIG_AsVal_int(obj1, &val2);
35343 if (!SWIG_IsOK(ecode2)) {
35344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35345 }
35346 arg2 = static_cast< int >(val2);
35347 ecode3 = SWIG_AsVal_int(obj2, &val3);
35348 if (!SWIG_IsOK(ecode3)) {
35349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35350 }
35351 arg3 = static_cast< int >(val3);
35352 {
35353 PyThreadState* __tstate = wxPyBeginAllowThreads();
35354 (arg1)->SetVirtualSize(arg2,arg3);
35355 wxPyEndAllowThreads(__tstate);
35356 if (PyErr_Occurred()) SWIG_fail;
35357 }
35358 resultobj = SWIG_Py_Void();
35359 return resultobj;
35360 fail:
35361 return NULL;
35362 }
35363
35364
35365 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35366 PyObject *resultobj = 0;
35367 wxWindow *arg1 = (wxWindow *) 0 ;
35368 wxSize result;
35369 void *argp1 = 0 ;
35370 int res1 = 0 ;
35371 PyObject *swig_obj[1] ;
35372
35373 if (!args) SWIG_fail;
35374 swig_obj[0] = args;
35375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35376 if (!SWIG_IsOK(res1)) {
35377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35378 }
35379 arg1 = reinterpret_cast< wxWindow * >(argp1);
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 result = ((wxWindow const *)arg1)->GetVirtualSize();
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35387 return resultobj;
35388 fail:
35389 return NULL;
35390 }
35391
35392
35393 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35394 PyObject *resultobj = 0;
35395 wxWindow *arg1 = (wxWindow *) 0 ;
35396 int *arg2 = (int *) 0 ;
35397 int *arg3 = (int *) 0 ;
35398 void *argp1 = 0 ;
35399 int res1 = 0 ;
35400 int temp2 ;
35401 int res2 = SWIG_TMPOBJ ;
35402 int temp3 ;
35403 int res3 = SWIG_TMPOBJ ;
35404 PyObject *swig_obj[1] ;
35405
35406 arg2 = &temp2;
35407 arg3 = &temp3;
35408 if (!args) SWIG_fail;
35409 swig_obj[0] = args;
35410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35411 if (!SWIG_IsOK(res1)) {
35412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35413 }
35414 arg1 = reinterpret_cast< wxWindow * >(argp1);
35415 {
35416 PyThreadState* __tstate = wxPyBeginAllowThreads();
35417 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35418 wxPyEndAllowThreads(__tstate);
35419 if (PyErr_Occurred()) SWIG_fail;
35420 }
35421 resultobj = SWIG_Py_Void();
35422 if (SWIG_IsTmpObj(res2)) {
35423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35424 } else {
35425 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35427 }
35428 if (SWIG_IsTmpObj(res3)) {
35429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35430 } else {
35431 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35433 }
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35441 PyObject *resultobj = 0;
35442 wxWindow *arg1 = (wxWindow *) 0 ;
35443 wxSize result;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 PyObject *swig_obj[1] ;
35447
35448 if (!args) SWIG_fail;
35449 swig_obj[0] = args;
35450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35451 if (!SWIG_IsOK(res1)) {
35452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35453 }
35454 arg1 = reinterpret_cast< wxWindow * >(argp1);
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35462 return resultobj;
35463 fail:
35464 return NULL;
35465 }
35466
35467
35468 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35469 PyObject *resultobj = 0;
35470 wxWindow *arg1 = (wxWindow *) 0 ;
35471 bool arg2 = (bool) true ;
35472 bool result;
35473 void *argp1 = 0 ;
35474 int res1 = 0 ;
35475 bool val2 ;
35476 int ecode2 = 0 ;
35477 PyObject * obj0 = 0 ;
35478 PyObject * obj1 = 0 ;
35479 char * kwnames[] = {
35480 (char *) "self",(char *) "show", NULL
35481 };
35482
35483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35485 if (!SWIG_IsOK(res1)) {
35486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35487 }
35488 arg1 = reinterpret_cast< wxWindow * >(argp1);
35489 if (obj1) {
35490 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35491 if (!SWIG_IsOK(ecode2)) {
35492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35493 }
35494 arg2 = static_cast< bool >(val2);
35495 }
35496 {
35497 PyThreadState* __tstate = wxPyBeginAllowThreads();
35498 result = (bool)(arg1)->Show(arg2);
35499 wxPyEndAllowThreads(__tstate);
35500 if (PyErr_Occurred()) SWIG_fail;
35501 }
35502 {
35503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35504 }
35505 return resultobj;
35506 fail:
35507 return NULL;
35508 }
35509
35510
35511 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35512 PyObject *resultobj = 0;
35513 wxWindow *arg1 = (wxWindow *) 0 ;
35514 bool result;
35515 void *argp1 = 0 ;
35516 int res1 = 0 ;
35517 PyObject *swig_obj[1] ;
35518
35519 if (!args) SWIG_fail;
35520 swig_obj[0] = args;
35521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35522 if (!SWIG_IsOK(res1)) {
35523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35524 }
35525 arg1 = reinterpret_cast< wxWindow * >(argp1);
35526 {
35527 PyThreadState* __tstate = wxPyBeginAllowThreads();
35528 result = (bool)(arg1)->Hide();
35529 wxPyEndAllowThreads(__tstate);
35530 if (PyErr_Occurred()) SWIG_fail;
35531 }
35532 {
35533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35534 }
35535 return resultobj;
35536 fail:
35537 return NULL;
35538 }
35539
35540
35541 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35542 PyObject *resultobj = 0;
35543 wxWindow *arg1 = (wxWindow *) 0 ;
35544 bool arg2 = (bool) true ;
35545 bool result;
35546 void *argp1 = 0 ;
35547 int res1 = 0 ;
35548 bool val2 ;
35549 int ecode2 = 0 ;
35550 PyObject * obj0 = 0 ;
35551 PyObject * obj1 = 0 ;
35552 char * kwnames[] = {
35553 (char *) "self",(char *) "enable", NULL
35554 };
35555
35556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35558 if (!SWIG_IsOK(res1)) {
35559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35560 }
35561 arg1 = reinterpret_cast< wxWindow * >(argp1);
35562 if (obj1) {
35563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35564 if (!SWIG_IsOK(ecode2)) {
35565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35566 }
35567 arg2 = static_cast< bool >(val2);
35568 }
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 result = (bool)(arg1)->Enable(arg2);
35572 wxPyEndAllowThreads(__tstate);
35573 if (PyErr_Occurred()) SWIG_fail;
35574 }
35575 {
35576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35577 }
35578 return resultobj;
35579 fail:
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35585 PyObject *resultobj = 0;
35586 wxWindow *arg1 = (wxWindow *) 0 ;
35587 bool result;
35588 void *argp1 = 0 ;
35589 int res1 = 0 ;
35590 PyObject *swig_obj[1] ;
35591
35592 if (!args) SWIG_fail;
35593 swig_obj[0] = args;
35594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35595 if (!SWIG_IsOK(res1)) {
35596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35597 }
35598 arg1 = reinterpret_cast< wxWindow * >(argp1);
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 result = (bool)(arg1)->Disable();
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 {
35606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35607 }
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35615 PyObject *resultobj = 0;
35616 wxWindow *arg1 = (wxWindow *) 0 ;
35617 bool result;
35618 void *argp1 = 0 ;
35619 int res1 = 0 ;
35620 PyObject *swig_obj[1] ;
35621
35622 if (!args) SWIG_fail;
35623 swig_obj[0] = args;
35624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35625 if (!SWIG_IsOK(res1)) {
35626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35627 }
35628 arg1 = reinterpret_cast< wxWindow * >(argp1);
35629 {
35630 PyThreadState* __tstate = wxPyBeginAllowThreads();
35631 result = (bool)((wxWindow const *)arg1)->IsShown();
35632 wxPyEndAllowThreads(__tstate);
35633 if (PyErr_Occurred()) SWIG_fail;
35634 }
35635 {
35636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35637 }
35638 return resultobj;
35639 fail:
35640 return NULL;
35641 }
35642
35643
35644 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35645 PyObject *resultobj = 0;
35646 wxWindow *arg1 = (wxWindow *) 0 ;
35647 bool result;
35648 void *argp1 = 0 ;
35649 int res1 = 0 ;
35650 PyObject *swig_obj[1] ;
35651
35652 if (!args) SWIG_fail;
35653 swig_obj[0] = args;
35654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 {
35660 PyThreadState* __tstate = wxPyBeginAllowThreads();
35661 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 {
35666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35667 }
35668 return resultobj;
35669 fail:
35670 return NULL;
35671 }
35672
35673
35674 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35675 PyObject *resultobj = 0;
35676 wxWindow *arg1 = (wxWindow *) 0 ;
35677 bool result;
35678 void *argp1 = 0 ;
35679 int res1 = 0 ;
35680 PyObject *swig_obj[1] ;
35681
35682 if (!args) SWIG_fail;
35683 swig_obj[0] = args;
35684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 {
35696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35697 }
35698 return resultobj;
35699 fail:
35700 return NULL;
35701 }
35702
35703
35704 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35705 PyObject *resultobj = 0;
35706 wxWindow *arg1 = (wxWindow *) 0 ;
35707 long arg2 ;
35708 void *argp1 = 0 ;
35709 int res1 = 0 ;
35710 long val2 ;
35711 int ecode2 = 0 ;
35712 PyObject * obj0 = 0 ;
35713 PyObject * obj1 = 0 ;
35714 char * kwnames[] = {
35715 (char *) "self",(char *) "style", NULL
35716 };
35717
35718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35722 }
35723 arg1 = reinterpret_cast< wxWindow * >(argp1);
35724 ecode2 = SWIG_AsVal_long(obj1, &val2);
35725 if (!SWIG_IsOK(ecode2)) {
35726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35727 }
35728 arg2 = static_cast< long >(val2);
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 (arg1)->SetWindowStyleFlag(arg2);
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 resultobj = SWIG_Py_Void();
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxWindow *arg1 = (wxWindow *) 0 ;
35745 long result;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748 PyObject *swig_obj[1] ;
35749
35750 if (!args) SWIG_fail;
35751 swig_obj[0] = args;
35752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35755 }
35756 arg1 = reinterpret_cast< wxWindow * >(argp1);
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 resultobj = SWIG_From_long(static_cast< long >(result));
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35771 PyObject *resultobj = 0;
35772 wxWindow *arg1 = (wxWindow *) 0 ;
35773 int arg2 ;
35774 bool result;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 int val2 ;
35778 int ecode2 = 0 ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 char * kwnames[] = {
35782 (char *) "self",(char *) "flag", NULL
35783 };
35784
35785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35787 if (!SWIG_IsOK(res1)) {
35788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35789 }
35790 arg1 = reinterpret_cast< wxWindow * >(argp1);
35791 ecode2 = SWIG_AsVal_int(obj1, &val2);
35792 if (!SWIG_IsOK(ecode2)) {
35793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35794 }
35795 arg2 = static_cast< int >(val2);
35796 {
35797 PyThreadState* __tstate = wxPyBeginAllowThreads();
35798 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 {
35803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35804 }
35805 return resultobj;
35806 fail:
35807 return NULL;
35808 }
35809
35810
35811 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35812 PyObject *resultobj = 0;
35813 wxWindow *arg1 = (wxWindow *) 0 ;
35814 bool result;
35815 void *argp1 = 0 ;
35816 int res1 = 0 ;
35817 PyObject *swig_obj[1] ;
35818
35819 if (!args) SWIG_fail;
35820 swig_obj[0] = args;
35821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35822 if (!SWIG_IsOK(res1)) {
35823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35824 }
35825 arg1 = reinterpret_cast< wxWindow * >(argp1);
35826 {
35827 PyThreadState* __tstate = wxPyBeginAllowThreads();
35828 result = (bool)((wxWindow const *)arg1)->IsRetained();
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 {
35833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35834 }
35835 return resultobj;
35836 fail:
35837 return NULL;
35838 }
35839
35840
35841 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35842 PyObject *resultobj = 0;
35843 wxWindow *arg1 = (wxWindow *) 0 ;
35844 long arg2 ;
35845 void *argp1 = 0 ;
35846 int res1 = 0 ;
35847 long val2 ;
35848 int ecode2 = 0 ;
35849 PyObject * obj0 = 0 ;
35850 PyObject * obj1 = 0 ;
35851 char * kwnames[] = {
35852 (char *) "self",(char *) "exStyle", NULL
35853 };
35854
35855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35859 }
35860 arg1 = reinterpret_cast< wxWindow * >(argp1);
35861 ecode2 = SWIG_AsVal_long(obj1, &val2);
35862 if (!SWIG_IsOK(ecode2)) {
35863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35864 }
35865 arg2 = static_cast< long >(val2);
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 (arg1)->SetExtraStyle(arg2);
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 resultobj = SWIG_Py_Void();
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35880 PyObject *resultobj = 0;
35881 wxWindow *arg1 = (wxWindow *) 0 ;
35882 long result;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 PyObject *swig_obj[1] ;
35886
35887 if (!args) SWIG_fail;
35888 swig_obj[0] = args;
35889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35892 }
35893 arg1 = reinterpret_cast< wxWindow * >(argp1);
35894 {
35895 PyThreadState* __tstate = wxPyBeginAllowThreads();
35896 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35897 wxPyEndAllowThreads(__tstate);
35898 if (PyErr_Occurred()) SWIG_fail;
35899 }
35900 resultobj = SWIG_From_long(static_cast< long >(result));
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35908 PyObject *resultobj = 0;
35909 wxWindow *arg1 = (wxWindow *) 0 ;
35910 bool arg2 = (bool) true ;
35911 void *argp1 = 0 ;
35912 int res1 = 0 ;
35913 bool val2 ;
35914 int ecode2 = 0 ;
35915 PyObject * obj0 = 0 ;
35916 PyObject * obj1 = 0 ;
35917 char * kwnames[] = {
35918 (char *) "self",(char *) "modal", NULL
35919 };
35920
35921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35923 if (!SWIG_IsOK(res1)) {
35924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35925 }
35926 arg1 = reinterpret_cast< wxWindow * >(argp1);
35927 if (obj1) {
35928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35929 if (!SWIG_IsOK(ecode2)) {
35930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35931 }
35932 arg2 = static_cast< bool >(val2);
35933 }
35934 {
35935 PyThreadState* __tstate = wxPyBeginAllowThreads();
35936 (arg1)->MakeModal(arg2);
35937 wxPyEndAllowThreads(__tstate);
35938 if (PyErr_Occurred()) SWIG_fail;
35939 }
35940 resultobj = SWIG_Py_Void();
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35948 PyObject *resultobj = 0;
35949 wxWindow *arg1 = (wxWindow *) 0 ;
35950 bool arg2 ;
35951 void *argp1 = 0 ;
35952 int res1 = 0 ;
35953 bool val2 ;
35954 int ecode2 = 0 ;
35955 PyObject * obj0 = 0 ;
35956 PyObject * obj1 = 0 ;
35957 char * kwnames[] = {
35958 (char *) "self",(char *) "enableTheme", NULL
35959 };
35960
35961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35963 if (!SWIG_IsOK(res1)) {
35964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35965 }
35966 arg1 = reinterpret_cast< wxWindow * >(argp1);
35967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35968 if (!SWIG_IsOK(ecode2)) {
35969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35970 }
35971 arg2 = static_cast< bool >(val2);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->SetThemeEnabled(arg2);
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_Py_Void();
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35986 PyObject *resultobj = 0;
35987 wxWindow *arg1 = (wxWindow *) 0 ;
35988 bool result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 PyObject *swig_obj[1] ;
35992
35993 if (!args) SWIG_fail;
35994 swig_obj[0] = args;
35995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35998 }
35999 arg1 = reinterpret_cast< wxWindow * >(argp1);
36000 {
36001 PyThreadState* __tstate = wxPyBeginAllowThreads();
36002 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 {
36007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36008 }
36009 return resultobj;
36010 fail:
36011 return NULL;
36012 }
36013
36014
36015 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36016 PyObject *resultobj = 0;
36017 wxWindow *arg1 = (wxWindow *) 0 ;
36018 void *argp1 = 0 ;
36019 int res1 = 0 ;
36020 PyObject *swig_obj[1] ;
36021
36022 if (!args) SWIG_fail;
36023 swig_obj[0] = args;
36024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36025 if (!SWIG_IsOK(res1)) {
36026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36027 }
36028 arg1 = reinterpret_cast< wxWindow * >(argp1);
36029 {
36030 PyThreadState* __tstate = wxPyBeginAllowThreads();
36031 (arg1)->SetFocus();
36032 wxPyEndAllowThreads(__tstate);
36033 if (PyErr_Occurred()) SWIG_fail;
36034 }
36035 resultobj = SWIG_Py_Void();
36036 return resultobj;
36037 fail:
36038 return NULL;
36039 }
36040
36041
36042 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36043 PyObject *resultobj = 0;
36044 wxWindow *arg1 = (wxWindow *) 0 ;
36045 void *argp1 = 0 ;
36046 int res1 = 0 ;
36047 PyObject *swig_obj[1] ;
36048
36049 if (!args) SWIG_fail;
36050 swig_obj[0] = args;
36051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36052 if (!SWIG_IsOK(res1)) {
36053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36054 }
36055 arg1 = reinterpret_cast< wxWindow * >(argp1);
36056 {
36057 PyThreadState* __tstate = wxPyBeginAllowThreads();
36058 (arg1)->SetFocusFromKbd();
36059 wxPyEndAllowThreads(__tstate);
36060 if (PyErr_Occurred()) SWIG_fail;
36061 }
36062 resultobj = SWIG_Py_Void();
36063 return resultobj;
36064 fail:
36065 return NULL;
36066 }
36067
36068
36069 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36070 PyObject *resultobj = 0;
36071 wxWindow *result = 0 ;
36072
36073 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36074 {
36075 if (!wxPyCheckForApp()) SWIG_fail;
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 result = (wxWindow *)wxWindow::FindFocus();
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 {
36082 resultobj = wxPyMake_wxObject(result, 0);
36083 }
36084 return resultobj;
36085 fail:
36086 return NULL;
36087 }
36088
36089
36090 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36091 PyObject *resultobj = 0;
36092 wxWindow *arg1 = (wxWindow *) 0 ;
36093 bool result;
36094 void *argp1 = 0 ;
36095 int res1 = 0 ;
36096 PyObject *swig_obj[1] ;
36097
36098 if (!args) SWIG_fail;
36099 swig_obj[0] = args;
36100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36101 if (!SWIG_IsOK(res1)) {
36102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36103 }
36104 arg1 = reinterpret_cast< wxWindow * >(argp1);
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 {
36112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36113 }
36114 return resultobj;
36115 fail:
36116 return NULL;
36117 }
36118
36119
36120 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36121 PyObject *resultobj = 0;
36122 wxWindow *arg1 = (wxWindow *) 0 ;
36123 bool 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_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 {
36136 PyThreadState* __tstate = wxPyBeginAllowThreads();
36137 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36138 wxPyEndAllowThreads(__tstate);
36139 if (PyErr_Occurred()) SWIG_fail;
36140 }
36141 {
36142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36143 }
36144 return resultobj;
36145 fail:
36146 return NULL;
36147 }
36148
36149
36150 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36151 PyObject *resultobj = 0;
36152 wxWindow *arg1 = (wxWindow *) 0 ;
36153 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 int val2 ;
36158 int ecode2 = 0 ;
36159 PyObject * obj0 = 0 ;
36160 PyObject * obj1 = 0 ;
36161 char * kwnames[] = {
36162 (char *) "self",(char *) "flags", NULL
36163 };
36164
36165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36167 if (!SWIG_IsOK(res1)) {
36168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36169 }
36170 arg1 = reinterpret_cast< wxWindow * >(argp1);
36171 if (obj1) {
36172 ecode2 = SWIG_AsVal_int(obj1, &val2);
36173 if (!SWIG_IsOK(ecode2)) {
36174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36175 }
36176 arg2 = static_cast< int >(val2);
36177 }
36178 {
36179 PyThreadState* __tstate = wxPyBeginAllowThreads();
36180 result = (bool)(arg1)->Navigate(arg2);
36181 wxPyEndAllowThreads(__tstate);
36182 if (PyErr_Occurred()) SWIG_fail;
36183 }
36184 {
36185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36186 }
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36194 PyObject *resultobj = 0;
36195 wxWindow *arg1 = (wxWindow *) 0 ;
36196 wxWindow *arg2 = (wxWindow *) 0 ;
36197 void *argp1 = 0 ;
36198 int res1 = 0 ;
36199 void *argp2 = 0 ;
36200 int res2 = 0 ;
36201 PyObject * obj0 = 0 ;
36202 PyObject * obj1 = 0 ;
36203 char * kwnames[] = {
36204 (char *) "self",(char *) "win", NULL
36205 };
36206
36207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36209 if (!SWIG_IsOK(res1)) {
36210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36211 }
36212 arg1 = reinterpret_cast< wxWindow * >(argp1);
36213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36214 if (!SWIG_IsOK(res2)) {
36215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36216 }
36217 arg2 = reinterpret_cast< wxWindow * >(argp2);
36218 {
36219 PyThreadState* __tstate = wxPyBeginAllowThreads();
36220 (arg1)->MoveAfterInTabOrder(arg2);
36221 wxPyEndAllowThreads(__tstate);
36222 if (PyErr_Occurred()) SWIG_fail;
36223 }
36224 resultobj = SWIG_Py_Void();
36225 return resultobj;
36226 fail:
36227 return NULL;
36228 }
36229
36230
36231 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36232 PyObject *resultobj = 0;
36233 wxWindow *arg1 = (wxWindow *) 0 ;
36234 wxWindow *arg2 = (wxWindow *) 0 ;
36235 void *argp1 = 0 ;
36236 int res1 = 0 ;
36237 void *argp2 = 0 ;
36238 int res2 = 0 ;
36239 PyObject * obj0 = 0 ;
36240 PyObject * obj1 = 0 ;
36241 char * kwnames[] = {
36242 (char *) "self",(char *) "win", NULL
36243 };
36244
36245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36247 if (!SWIG_IsOK(res1)) {
36248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36249 }
36250 arg1 = reinterpret_cast< wxWindow * >(argp1);
36251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36252 if (!SWIG_IsOK(res2)) {
36253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36254 }
36255 arg2 = reinterpret_cast< wxWindow * >(argp2);
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 (arg1)->MoveBeforeInTabOrder(arg2);
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 resultobj = SWIG_Py_Void();
36263 return resultobj;
36264 fail:
36265 return NULL;
36266 }
36267
36268
36269 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36270 PyObject *resultobj = 0;
36271 wxWindow *arg1 = (wxWindow *) 0 ;
36272 PyObject *result = 0 ;
36273 void *argp1 = 0 ;
36274 int res1 = 0 ;
36275 PyObject *swig_obj[1] ;
36276
36277 if (!args) SWIG_fail;
36278 swig_obj[0] = args;
36279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36280 if (!SWIG_IsOK(res1)) {
36281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36282 }
36283 arg1 = reinterpret_cast< wxWindow * >(argp1);
36284 {
36285 PyThreadState* __tstate = wxPyBeginAllowThreads();
36286 result = (PyObject *)wxWindow_GetChildren(arg1);
36287 wxPyEndAllowThreads(__tstate);
36288 if (PyErr_Occurred()) SWIG_fail;
36289 }
36290 resultobj = result;
36291 return resultobj;
36292 fail:
36293 return NULL;
36294 }
36295
36296
36297 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36298 PyObject *resultobj = 0;
36299 wxWindow *arg1 = (wxWindow *) 0 ;
36300 wxWindow *result = 0 ;
36301 void *argp1 = 0 ;
36302 int res1 = 0 ;
36303 PyObject *swig_obj[1] ;
36304
36305 if (!args) SWIG_fail;
36306 swig_obj[0] = args;
36307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36310 }
36311 arg1 = reinterpret_cast< wxWindow * >(argp1);
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 {
36319 resultobj = wxPyMake_wxObject(result, 0);
36320 }
36321 return resultobj;
36322 fail:
36323 return NULL;
36324 }
36325
36326
36327 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36328 PyObject *resultobj = 0;
36329 wxWindow *arg1 = (wxWindow *) 0 ;
36330 wxWindow *result = 0 ;
36331 void *argp1 = 0 ;
36332 int res1 = 0 ;
36333 PyObject *swig_obj[1] ;
36334
36335 if (!args) SWIG_fail;
36336 swig_obj[0] = args;
36337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36338 if (!SWIG_IsOK(res1)) {
36339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36340 }
36341 arg1 = reinterpret_cast< wxWindow * >(argp1);
36342 {
36343 PyThreadState* __tstate = wxPyBeginAllowThreads();
36344 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36345 wxPyEndAllowThreads(__tstate);
36346 if (PyErr_Occurred()) SWIG_fail;
36347 }
36348 {
36349 resultobj = wxPyMake_wxObject(result, 0);
36350 }
36351 return resultobj;
36352 fail:
36353 return NULL;
36354 }
36355
36356
36357 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36358 PyObject *resultobj = 0;
36359 wxWindow *arg1 = (wxWindow *) 0 ;
36360 bool result;
36361 void *argp1 = 0 ;
36362 int res1 = 0 ;
36363 PyObject *swig_obj[1] ;
36364
36365 if (!args) SWIG_fail;
36366 swig_obj[0] = args;
36367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36368 if (!SWIG_IsOK(res1)) {
36369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36370 }
36371 arg1 = reinterpret_cast< wxWindow * >(argp1);
36372 {
36373 PyThreadState* __tstate = wxPyBeginAllowThreads();
36374 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36375 wxPyEndAllowThreads(__tstate);
36376 if (PyErr_Occurred()) SWIG_fail;
36377 }
36378 {
36379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36380 }
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36388 PyObject *resultobj = 0;
36389 wxWindow *arg1 = (wxWindow *) 0 ;
36390 wxWindow *arg2 = (wxWindow *) 0 ;
36391 bool result;
36392 void *argp1 = 0 ;
36393 int res1 = 0 ;
36394 void *argp2 = 0 ;
36395 int res2 = 0 ;
36396 PyObject * obj0 = 0 ;
36397 PyObject * obj1 = 0 ;
36398 char * kwnames[] = {
36399 (char *) "self",(char *) "newParent", NULL
36400 };
36401
36402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36404 if (!SWIG_IsOK(res1)) {
36405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36406 }
36407 arg1 = reinterpret_cast< wxWindow * >(argp1);
36408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36409 if (!SWIG_IsOK(res2)) {
36410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36411 }
36412 arg2 = reinterpret_cast< wxWindow * >(argp2);
36413 {
36414 PyThreadState* __tstate = wxPyBeginAllowThreads();
36415 result = (bool)(arg1)->Reparent(arg2);
36416 wxPyEndAllowThreads(__tstate);
36417 if (PyErr_Occurred()) SWIG_fail;
36418 }
36419 {
36420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36421 }
36422 return resultobj;
36423 fail:
36424 return NULL;
36425 }
36426
36427
36428 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36429 PyObject *resultobj = 0;
36430 wxWindow *arg1 = (wxWindow *) 0 ;
36431 wxWindow *arg2 = (wxWindow *) 0 ;
36432 void *argp1 = 0 ;
36433 int res1 = 0 ;
36434 void *argp2 = 0 ;
36435 int res2 = 0 ;
36436 PyObject * obj0 = 0 ;
36437 PyObject * obj1 = 0 ;
36438 char * kwnames[] = {
36439 (char *) "self",(char *) "child", NULL
36440 };
36441
36442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36444 if (!SWIG_IsOK(res1)) {
36445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36446 }
36447 arg1 = reinterpret_cast< wxWindow * >(argp1);
36448 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36449 if (!SWIG_IsOK(res2)) {
36450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36451 }
36452 arg2 = reinterpret_cast< wxWindow * >(argp2);
36453 {
36454 PyThreadState* __tstate = wxPyBeginAllowThreads();
36455 (arg1)->AddChild(arg2);
36456 wxPyEndAllowThreads(__tstate);
36457 if (PyErr_Occurred()) SWIG_fail;
36458 }
36459 resultobj = SWIG_Py_Void();
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36467 PyObject *resultobj = 0;
36468 wxWindow *arg1 = (wxWindow *) 0 ;
36469 wxWindow *arg2 = (wxWindow *) 0 ;
36470 void *argp1 = 0 ;
36471 int res1 = 0 ;
36472 void *argp2 = 0 ;
36473 int res2 = 0 ;
36474 PyObject * obj0 = 0 ;
36475 PyObject * obj1 = 0 ;
36476 char * kwnames[] = {
36477 (char *) "self",(char *) "child", NULL
36478 };
36479
36480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36482 if (!SWIG_IsOK(res1)) {
36483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36484 }
36485 arg1 = reinterpret_cast< wxWindow * >(argp1);
36486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36487 if (!SWIG_IsOK(res2)) {
36488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36489 }
36490 arg2 = reinterpret_cast< wxWindow * >(argp2);
36491 {
36492 PyThreadState* __tstate = wxPyBeginAllowThreads();
36493 (arg1)->RemoveChild(arg2);
36494 wxPyEndAllowThreads(__tstate);
36495 if (PyErr_Occurred()) SWIG_fail;
36496 }
36497 resultobj = SWIG_Py_Void();
36498 return resultobj;
36499 fail:
36500 return NULL;
36501 }
36502
36503
36504 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36505 PyObject *resultobj = 0;
36506 wxWindow *arg1 = (wxWindow *) 0 ;
36507 bool arg2 ;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 bool val2 ;
36511 int ecode2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "on", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36525 if (!SWIG_IsOK(ecode2)) {
36526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36527 }
36528 arg2 = static_cast< bool >(val2);
36529 {
36530 PyThreadState* __tstate = wxPyBeginAllowThreads();
36531 wxWindow_SetDoubleBuffered(arg1,arg2);
36532 wxPyEndAllowThreads(__tstate);
36533 if (PyErr_Occurred()) SWIG_fail;
36534 }
36535 resultobj = SWIG_Py_Void();
36536 return resultobj;
36537 fail:
36538 return NULL;
36539 }
36540
36541
36542 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36543 PyObject *resultobj = 0;
36544 wxWindow *arg1 = (wxWindow *) 0 ;
36545 long arg2 ;
36546 wxWindow *result = 0 ;
36547 void *argp1 = 0 ;
36548 int res1 = 0 ;
36549 long val2 ;
36550 int ecode2 = 0 ;
36551 PyObject * obj0 = 0 ;
36552 PyObject * obj1 = 0 ;
36553 char * kwnames[] = {
36554 (char *) "self",(char *) "winid", NULL
36555 };
36556
36557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36561 }
36562 arg1 = reinterpret_cast< wxWindow * >(argp1);
36563 ecode2 = SWIG_AsVal_long(obj1, &val2);
36564 if (!SWIG_IsOK(ecode2)) {
36565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36566 }
36567 arg2 = static_cast< long >(val2);
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = (wxWindow *)(arg1)->FindWindow(arg2);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 {
36575 resultobj = wxPyMake_wxObject(result, 0);
36576 }
36577 return resultobj;
36578 fail:
36579 return NULL;
36580 }
36581
36582
36583 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36584 PyObject *resultobj = 0;
36585 wxWindow *arg1 = (wxWindow *) 0 ;
36586 wxString *arg2 = 0 ;
36587 wxWindow *result = 0 ;
36588 void *argp1 = 0 ;
36589 int res1 = 0 ;
36590 bool temp2 = false ;
36591 PyObject * obj0 = 0 ;
36592 PyObject * obj1 = 0 ;
36593 char * kwnames[] = {
36594 (char *) "self",(char *) "name", NULL
36595 };
36596
36597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36599 if (!SWIG_IsOK(res1)) {
36600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36601 }
36602 arg1 = reinterpret_cast< wxWindow * >(argp1);
36603 {
36604 arg2 = wxString_in_helper(obj1);
36605 if (arg2 == NULL) SWIG_fail;
36606 temp2 = true;
36607 }
36608 {
36609 PyThreadState* __tstate = wxPyBeginAllowThreads();
36610 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36611 wxPyEndAllowThreads(__tstate);
36612 if (PyErr_Occurred()) SWIG_fail;
36613 }
36614 {
36615 resultobj = wxPyMake_wxObject(result, 0);
36616 }
36617 {
36618 if (temp2)
36619 delete arg2;
36620 }
36621 return resultobj;
36622 fail:
36623 {
36624 if (temp2)
36625 delete arg2;
36626 }
36627 return NULL;
36628 }
36629
36630
36631 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36632 PyObject *resultobj = 0;
36633 wxWindow *arg1 = (wxWindow *) 0 ;
36634 wxEvtHandler *result = 0 ;
36635 void *argp1 = 0 ;
36636 int res1 = 0 ;
36637 PyObject *swig_obj[1] ;
36638
36639 if (!args) SWIG_fail;
36640 swig_obj[0] = args;
36641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36642 if (!SWIG_IsOK(res1)) {
36643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36644 }
36645 arg1 = reinterpret_cast< wxWindow * >(argp1);
36646 {
36647 PyThreadState* __tstate = wxPyBeginAllowThreads();
36648 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36649 wxPyEndAllowThreads(__tstate);
36650 if (PyErr_Occurred()) SWIG_fail;
36651 }
36652 {
36653 resultobj = wxPyMake_wxObject(result, 0);
36654 }
36655 return resultobj;
36656 fail:
36657 return NULL;
36658 }
36659
36660
36661 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36662 PyObject *resultobj = 0;
36663 wxWindow *arg1 = (wxWindow *) 0 ;
36664 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36665 void *argp1 = 0 ;
36666 int res1 = 0 ;
36667 void *argp2 = 0 ;
36668 int res2 = 0 ;
36669 PyObject * obj0 = 0 ;
36670 PyObject * obj1 = 0 ;
36671 char * kwnames[] = {
36672 (char *) "self",(char *) "handler", NULL
36673 };
36674
36675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36677 if (!SWIG_IsOK(res1)) {
36678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36679 }
36680 arg1 = reinterpret_cast< wxWindow * >(argp1);
36681 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36682 if (!SWIG_IsOK(res2)) {
36683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36684 }
36685 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 (arg1)->SetEventHandler(arg2);
36689 wxPyEndAllowThreads(__tstate);
36690 if (PyErr_Occurred()) SWIG_fail;
36691 }
36692 resultobj = SWIG_Py_Void();
36693 return resultobj;
36694 fail:
36695 return NULL;
36696 }
36697
36698
36699 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36700 PyObject *resultobj = 0;
36701 wxWindow *arg1 = (wxWindow *) 0 ;
36702 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36703 void *argp1 = 0 ;
36704 int res1 = 0 ;
36705 void *argp2 = 0 ;
36706 int res2 = 0 ;
36707 PyObject * obj0 = 0 ;
36708 PyObject * obj1 = 0 ;
36709 char * kwnames[] = {
36710 (char *) "self",(char *) "handler", NULL
36711 };
36712
36713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36715 if (!SWIG_IsOK(res1)) {
36716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36717 }
36718 arg1 = reinterpret_cast< wxWindow * >(argp1);
36719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36720 if (!SWIG_IsOK(res2)) {
36721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36722 }
36723 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36724 {
36725 PyThreadState* __tstate = wxPyBeginAllowThreads();
36726 (arg1)->PushEventHandler(arg2);
36727 wxPyEndAllowThreads(__tstate);
36728 if (PyErr_Occurred()) SWIG_fail;
36729 }
36730 resultobj = SWIG_Py_Void();
36731 return resultobj;
36732 fail:
36733 return NULL;
36734 }
36735
36736
36737 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36738 PyObject *resultobj = 0;
36739 wxWindow *arg1 = (wxWindow *) 0 ;
36740 bool arg2 = (bool) false ;
36741 wxEvtHandler *result = 0 ;
36742 void *argp1 = 0 ;
36743 int res1 = 0 ;
36744 bool val2 ;
36745 int ecode2 = 0 ;
36746 PyObject * obj0 = 0 ;
36747 PyObject * obj1 = 0 ;
36748 char * kwnames[] = {
36749 (char *) "self",(char *) "deleteHandler", NULL
36750 };
36751
36752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36754 if (!SWIG_IsOK(res1)) {
36755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36756 }
36757 arg1 = reinterpret_cast< wxWindow * >(argp1);
36758 if (obj1) {
36759 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36760 if (!SWIG_IsOK(ecode2)) {
36761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36762 }
36763 arg2 = static_cast< bool >(val2);
36764 }
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36768 wxPyEndAllowThreads(__tstate);
36769 if (PyErr_Occurred()) SWIG_fail;
36770 }
36771 {
36772 resultobj = wxPyMake_wxObject(result, 0);
36773 }
36774 return resultobj;
36775 fail:
36776 return NULL;
36777 }
36778
36779
36780 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36781 PyObject *resultobj = 0;
36782 wxWindow *arg1 = (wxWindow *) 0 ;
36783 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36784 bool result;
36785 void *argp1 = 0 ;
36786 int res1 = 0 ;
36787 void *argp2 = 0 ;
36788 int res2 = 0 ;
36789 PyObject * obj0 = 0 ;
36790 PyObject * obj1 = 0 ;
36791 char * kwnames[] = {
36792 (char *) "self",(char *) "handler", NULL
36793 };
36794
36795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36797 if (!SWIG_IsOK(res1)) {
36798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36799 }
36800 arg1 = reinterpret_cast< wxWindow * >(argp1);
36801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36802 if (!SWIG_IsOK(res2)) {
36803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36804 }
36805 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (bool)(arg1)->RemoveEventHandler(arg2);
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj = 0;
36823 wxWindow *arg1 = (wxWindow *) 0 ;
36824 wxValidator *arg2 = 0 ;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 void *argp2 = 0 ;
36828 int res2 = 0 ;
36829 PyObject * obj0 = 0 ;
36830 PyObject * obj1 = 0 ;
36831 char * kwnames[] = {
36832 (char *) "self",(char *) "validator", NULL
36833 };
36834
36835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36837 if (!SWIG_IsOK(res1)) {
36838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36839 }
36840 arg1 = reinterpret_cast< wxWindow * >(argp1);
36841 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36842 if (!SWIG_IsOK(res2)) {
36843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36844 }
36845 if (!argp2) {
36846 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36847 }
36848 arg2 = reinterpret_cast< wxValidator * >(argp2);
36849 {
36850 PyThreadState* __tstate = wxPyBeginAllowThreads();
36851 (arg1)->SetValidator((wxValidator const &)*arg2);
36852 wxPyEndAllowThreads(__tstate);
36853 if (PyErr_Occurred()) SWIG_fail;
36854 }
36855 resultobj = SWIG_Py_Void();
36856 return resultobj;
36857 fail:
36858 return NULL;
36859 }
36860
36861
36862 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36863 PyObject *resultobj = 0;
36864 wxWindow *arg1 = (wxWindow *) 0 ;
36865 wxValidator *result = 0 ;
36866 void *argp1 = 0 ;
36867 int res1 = 0 ;
36868 PyObject *swig_obj[1] ;
36869
36870 if (!args) SWIG_fail;
36871 swig_obj[0] = args;
36872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36873 if (!SWIG_IsOK(res1)) {
36874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36875 }
36876 arg1 = reinterpret_cast< wxWindow * >(argp1);
36877 {
36878 PyThreadState* __tstate = wxPyBeginAllowThreads();
36879 result = (wxValidator *)(arg1)->GetValidator();
36880 wxPyEndAllowThreads(__tstate);
36881 if (PyErr_Occurred()) SWIG_fail;
36882 }
36883 {
36884 resultobj = wxPyMake_wxObject(result, (bool)0);
36885 }
36886 return resultobj;
36887 fail:
36888 return NULL;
36889 }
36890
36891
36892 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36893 PyObject *resultobj = 0;
36894 wxWindow *arg1 = (wxWindow *) 0 ;
36895 bool result;
36896 void *argp1 = 0 ;
36897 int res1 = 0 ;
36898 PyObject *swig_obj[1] ;
36899
36900 if (!args) SWIG_fail;
36901 swig_obj[0] = args;
36902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36903 if (!SWIG_IsOK(res1)) {
36904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36905 }
36906 arg1 = reinterpret_cast< wxWindow * >(argp1);
36907 {
36908 PyThreadState* __tstate = wxPyBeginAllowThreads();
36909 result = (bool)(arg1)->Validate();
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 {
36914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36915 }
36916 return resultobj;
36917 fail:
36918 return NULL;
36919 }
36920
36921
36922 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36923 PyObject *resultobj = 0;
36924 wxWindow *arg1 = (wxWindow *) 0 ;
36925 bool result;
36926 void *argp1 = 0 ;
36927 int res1 = 0 ;
36928 PyObject *swig_obj[1] ;
36929
36930 if (!args) SWIG_fail;
36931 swig_obj[0] = args;
36932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36933 if (!SWIG_IsOK(res1)) {
36934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36935 }
36936 arg1 = reinterpret_cast< wxWindow * >(argp1);
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 result = (bool)(arg1)->TransferDataToWindow();
36940 wxPyEndAllowThreads(__tstate);
36941 if (PyErr_Occurred()) SWIG_fail;
36942 }
36943 {
36944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36945 }
36946 return resultobj;
36947 fail:
36948 return NULL;
36949 }
36950
36951
36952 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36953 PyObject *resultobj = 0;
36954 wxWindow *arg1 = (wxWindow *) 0 ;
36955 bool result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 PyObject *swig_obj[1] ;
36959
36960 if (!args) SWIG_fail;
36961 swig_obj[0] = args;
36962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36965 }
36966 arg1 = reinterpret_cast< wxWindow * >(argp1);
36967 {
36968 PyThreadState* __tstate = wxPyBeginAllowThreads();
36969 result = (bool)(arg1)->TransferDataFromWindow();
36970 wxPyEndAllowThreads(__tstate);
36971 if (PyErr_Occurred()) SWIG_fail;
36972 }
36973 {
36974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36975 }
36976 return resultobj;
36977 fail:
36978 return NULL;
36979 }
36980
36981
36982 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36983 PyObject *resultobj = 0;
36984 wxWindow *arg1 = (wxWindow *) 0 ;
36985 void *argp1 = 0 ;
36986 int res1 = 0 ;
36987 PyObject *swig_obj[1] ;
36988
36989 if (!args) SWIG_fail;
36990 swig_obj[0] = args;
36991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36992 if (!SWIG_IsOK(res1)) {
36993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36994 }
36995 arg1 = reinterpret_cast< wxWindow * >(argp1);
36996 {
36997 PyThreadState* __tstate = wxPyBeginAllowThreads();
36998 (arg1)->InitDialog();
36999 wxPyEndAllowThreads(__tstate);
37000 if (PyErr_Occurred()) SWIG_fail;
37001 }
37002 resultobj = SWIG_Py_Void();
37003 return resultobj;
37004 fail:
37005 return NULL;
37006 }
37007
37008
37009 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37010 PyObject *resultobj = 0;
37011 wxWindow *arg1 = (wxWindow *) 0 ;
37012 wxAcceleratorTable *arg2 = 0 ;
37013 void *argp1 = 0 ;
37014 int res1 = 0 ;
37015 void *argp2 = 0 ;
37016 int res2 = 0 ;
37017 PyObject * obj0 = 0 ;
37018 PyObject * obj1 = 0 ;
37019 char * kwnames[] = {
37020 (char *) "self",(char *) "accel", NULL
37021 };
37022
37023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37027 }
37028 arg1 = reinterpret_cast< wxWindow * >(argp1);
37029 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37030 if (!SWIG_IsOK(res2)) {
37031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37032 }
37033 if (!argp2) {
37034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37035 }
37036 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37037 {
37038 PyThreadState* __tstate = wxPyBeginAllowThreads();
37039 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 resultobj = SWIG_Py_Void();
37044 return resultobj;
37045 fail:
37046 return NULL;
37047 }
37048
37049
37050 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37051 PyObject *resultobj = 0;
37052 wxWindow *arg1 = (wxWindow *) 0 ;
37053 wxAcceleratorTable *result = 0 ;
37054 void *argp1 = 0 ;
37055 int res1 = 0 ;
37056 PyObject *swig_obj[1] ;
37057
37058 if (!args) SWIG_fail;
37059 swig_obj[0] = args;
37060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37061 if (!SWIG_IsOK(res1)) {
37062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37063 }
37064 arg1 = reinterpret_cast< wxWindow * >(argp1);
37065 {
37066 PyThreadState* __tstate = wxPyBeginAllowThreads();
37067 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37068 wxPyEndAllowThreads(__tstate);
37069 if (PyErr_Occurred()) SWIG_fail;
37070 }
37071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37072 return resultobj;
37073 fail:
37074 return NULL;
37075 }
37076
37077
37078 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37079 PyObject *resultobj = 0;
37080 wxWindow *arg1 = (wxWindow *) 0 ;
37081 int arg2 ;
37082 int arg3 ;
37083 int arg4 ;
37084 bool result;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 int val2 ;
37088 int ecode2 = 0 ;
37089 int val3 ;
37090 int ecode3 = 0 ;
37091 int val4 ;
37092 int ecode4 = 0 ;
37093 PyObject * obj0 = 0 ;
37094 PyObject * obj1 = 0 ;
37095 PyObject * obj2 = 0 ;
37096 PyObject * obj3 = 0 ;
37097 char * kwnames[] = {
37098 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37099 };
37100
37101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37103 if (!SWIG_IsOK(res1)) {
37104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37105 }
37106 arg1 = reinterpret_cast< wxWindow * >(argp1);
37107 ecode2 = SWIG_AsVal_int(obj1, &val2);
37108 if (!SWIG_IsOK(ecode2)) {
37109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37110 }
37111 arg2 = static_cast< int >(val2);
37112 ecode3 = SWIG_AsVal_int(obj2, &val3);
37113 if (!SWIG_IsOK(ecode3)) {
37114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37115 }
37116 arg3 = static_cast< int >(val3);
37117 ecode4 = SWIG_AsVal_int(obj3, &val4);
37118 if (!SWIG_IsOK(ecode4)) {
37119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37120 }
37121 arg4 = static_cast< int >(val4);
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37125 wxPyEndAllowThreads(__tstate);
37126 if (PyErr_Occurred()) SWIG_fail;
37127 }
37128 {
37129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37130 }
37131 return resultobj;
37132 fail:
37133 return NULL;
37134 }
37135
37136
37137 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37138 PyObject *resultobj = 0;
37139 wxWindow *arg1 = (wxWindow *) 0 ;
37140 int arg2 ;
37141 bool result;
37142 void *argp1 = 0 ;
37143 int res1 = 0 ;
37144 int val2 ;
37145 int ecode2 = 0 ;
37146 PyObject * obj0 = 0 ;
37147 PyObject * obj1 = 0 ;
37148 char * kwnames[] = {
37149 (char *) "self",(char *) "hotkeyId", NULL
37150 };
37151
37152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37156 }
37157 arg1 = reinterpret_cast< wxWindow * >(argp1);
37158 ecode2 = SWIG_AsVal_int(obj1, &val2);
37159 if (!SWIG_IsOK(ecode2)) {
37160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37161 }
37162 arg2 = static_cast< int >(val2);
37163 {
37164 PyThreadState* __tstate = wxPyBeginAllowThreads();
37165 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37166 wxPyEndAllowThreads(__tstate);
37167 if (PyErr_Occurred()) SWIG_fail;
37168 }
37169 {
37170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37171 }
37172 return resultobj;
37173 fail:
37174 return NULL;
37175 }
37176
37177
37178 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37179 PyObject *resultobj = 0;
37180 wxWindow *arg1 = (wxWindow *) 0 ;
37181 wxPoint *arg2 = 0 ;
37182 wxPoint result;
37183 void *argp1 = 0 ;
37184 int res1 = 0 ;
37185 wxPoint temp2 ;
37186 PyObject * obj0 = 0 ;
37187 PyObject * obj1 = 0 ;
37188 char * kwnames[] = {
37189 (char *) "self",(char *) "pt", NULL
37190 };
37191
37192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37194 if (!SWIG_IsOK(res1)) {
37195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37196 }
37197 arg1 = reinterpret_cast< wxWindow * >(argp1);
37198 {
37199 arg2 = &temp2;
37200 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37201 }
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37205 wxPyEndAllowThreads(__tstate);
37206 if (PyErr_Occurred()) SWIG_fail;
37207 }
37208 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37209 return resultobj;
37210 fail:
37211 return NULL;
37212 }
37213
37214
37215 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37216 PyObject *resultobj = 0;
37217 wxWindow *arg1 = (wxWindow *) 0 ;
37218 wxSize *arg2 = 0 ;
37219 wxSize result;
37220 void *argp1 = 0 ;
37221 int res1 = 0 ;
37222 wxSize temp2 ;
37223 PyObject * obj0 = 0 ;
37224 PyObject * obj1 = 0 ;
37225 char * kwnames[] = {
37226 (char *) "self",(char *) "sz", NULL
37227 };
37228
37229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37231 if (!SWIG_IsOK(res1)) {
37232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37233 }
37234 arg1 = reinterpret_cast< wxWindow * >(argp1);
37235 {
37236 arg2 = &temp2;
37237 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37238 }
37239 {
37240 PyThreadState* __tstate = wxPyBeginAllowThreads();
37241 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37242 wxPyEndAllowThreads(__tstate);
37243 if (PyErr_Occurred()) SWIG_fail;
37244 }
37245 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37246 return resultobj;
37247 fail:
37248 return NULL;
37249 }
37250
37251
37252 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37253 PyObject *resultobj = 0;
37254 wxWindow *arg1 = (wxWindow *) 0 ;
37255 wxPoint *arg2 = 0 ;
37256 wxPoint result;
37257 void *argp1 = 0 ;
37258 int res1 = 0 ;
37259 wxPoint temp2 ;
37260 PyObject * obj0 = 0 ;
37261 PyObject * obj1 = 0 ;
37262 char * kwnames[] = {
37263 (char *) "self",(char *) "pt", NULL
37264 };
37265
37266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37268 if (!SWIG_IsOK(res1)) {
37269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37270 }
37271 arg1 = reinterpret_cast< wxWindow * >(argp1);
37272 {
37273 arg2 = &temp2;
37274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37275 }
37276 {
37277 PyThreadState* __tstate = wxPyBeginAllowThreads();
37278 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37279 wxPyEndAllowThreads(__tstate);
37280 if (PyErr_Occurred()) SWIG_fail;
37281 }
37282 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37283 return resultobj;
37284 fail:
37285 return NULL;
37286 }
37287
37288
37289 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37290 PyObject *resultobj = 0;
37291 wxWindow *arg1 = (wxWindow *) 0 ;
37292 wxSize *arg2 = 0 ;
37293 wxSize result;
37294 void *argp1 = 0 ;
37295 int res1 = 0 ;
37296 wxSize temp2 ;
37297 PyObject * obj0 = 0 ;
37298 PyObject * obj1 = 0 ;
37299 char * kwnames[] = {
37300 (char *) "self",(char *) "sz", NULL
37301 };
37302
37303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37305 if (!SWIG_IsOK(res1)) {
37306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37307 }
37308 arg1 = reinterpret_cast< wxWindow * >(argp1);
37309 {
37310 arg2 = &temp2;
37311 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37312 }
37313 {
37314 PyThreadState* __tstate = wxPyBeginAllowThreads();
37315 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37316 wxPyEndAllowThreads(__tstate);
37317 if (PyErr_Occurred()) SWIG_fail;
37318 }
37319 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37327 PyObject *resultobj = 0;
37328 wxWindow *arg1 = (wxWindow *) 0 ;
37329 wxPoint *arg2 = 0 ;
37330 wxPoint result;
37331 void *argp1 = 0 ;
37332 int res1 = 0 ;
37333 wxPoint temp2 ;
37334 PyObject * obj0 = 0 ;
37335 PyObject * obj1 = 0 ;
37336 char * kwnames[] = {
37337 (char *) "self",(char *) "pt", NULL
37338 };
37339
37340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37342 if (!SWIG_IsOK(res1)) {
37343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37344 }
37345 arg1 = reinterpret_cast< wxWindow * >(argp1);
37346 {
37347 arg2 = &temp2;
37348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37349 }
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37357 return resultobj;
37358 fail:
37359 return NULL;
37360 }
37361
37362
37363 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37364 PyObject *resultobj = 0;
37365 wxWindow *arg1 = (wxWindow *) 0 ;
37366 wxSize *arg2 = 0 ;
37367 wxSize result;
37368 void *argp1 = 0 ;
37369 int res1 = 0 ;
37370 wxSize temp2 ;
37371 PyObject * obj0 = 0 ;
37372 PyObject * obj1 = 0 ;
37373 char * kwnames[] = {
37374 (char *) "self",(char *) "sz", NULL
37375 };
37376
37377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res1)) {
37380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37381 }
37382 arg1 = reinterpret_cast< wxWindow * >(argp1);
37383 {
37384 arg2 = &temp2;
37385 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37386 }
37387 {
37388 PyThreadState* __tstate = wxPyBeginAllowThreads();
37389 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37390 wxPyEndAllowThreads(__tstate);
37391 if (PyErr_Occurred()) SWIG_fail;
37392 }
37393 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37401 PyObject *resultobj = 0;
37402 wxWindow *arg1 = (wxWindow *) 0 ;
37403 int arg2 ;
37404 int arg3 ;
37405 void *argp1 = 0 ;
37406 int res1 = 0 ;
37407 int val2 ;
37408 int ecode2 = 0 ;
37409 int val3 ;
37410 int ecode3 = 0 ;
37411 PyObject * obj0 = 0 ;
37412 PyObject * obj1 = 0 ;
37413 PyObject * obj2 = 0 ;
37414 char * kwnames[] = {
37415 (char *) "self",(char *) "x",(char *) "y", NULL
37416 };
37417
37418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37420 if (!SWIG_IsOK(res1)) {
37421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37422 }
37423 arg1 = reinterpret_cast< wxWindow * >(argp1);
37424 ecode2 = SWIG_AsVal_int(obj1, &val2);
37425 if (!SWIG_IsOK(ecode2)) {
37426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37427 }
37428 arg2 = static_cast< int >(val2);
37429 ecode3 = SWIG_AsVal_int(obj2, &val3);
37430 if (!SWIG_IsOK(ecode3)) {
37431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37432 }
37433 arg3 = static_cast< int >(val3);
37434 {
37435 PyThreadState* __tstate = wxPyBeginAllowThreads();
37436 (arg1)->WarpPointer(arg2,arg3);
37437 wxPyEndAllowThreads(__tstate);
37438 if (PyErr_Occurred()) SWIG_fail;
37439 }
37440 resultobj = SWIG_Py_Void();
37441 return resultobj;
37442 fail:
37443 return NULL;
37444 }
37445
37446
37447 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37448 PyObject *resultobj = 0;
37449 wxWindow *arg1 = (wxWindow *) 0 ;
37450 void *argp1 = 0 ;
37451 int res1 = 0 ;
37452 PyObject *swig_obj[1] ;
37453
37454 if (!args) SWIG_fail;
37455 swig_obj[0] = args;
37456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37457 if (!SWIG_IsOK(res1)) {
37458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37459 }
37460 arg1 = reinterpret_cast< wxWindow * >(argp1);
37461 {
37462 PyThreadState* __tstate = wxPyBeginAllowThreads();
37463 (arg1)->CaptureMouse();
37464 wxPyEndAllowThreads(__tstate);
37465 if (PyErr_Occurred()) SWIG_fail;
37466 }
37467 resultobj = SWIG_Py_Void();
37468 return resultobj;
37469 fail:
37470 return NULL;
37471 }
37472
37473
37474 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37475 PyObject *resultobj = 0;
37476 wxWindow *arg1 = (wxWindow *) 0 ;
37477 void *argp1 = 0 ;
37478 int res1 = 0 ;
37479 PyObject *swig_obj[1] ;
37480
37481 if (!args) SWIG_fail;
37482 swig_obj[0] = args;
37483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37484 if (!SWIG_IsOK(res1)) {
37485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37486 }
37487 arg1 = reinterpret_cast< wxWindow * >(argp1);
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 (arg1)->ReleaseMouse();
37491 wxPyEndAllowThreads(__tstate);
37492 if (PyErr_Occurred()) SWIG_fail;
37493 }
37494 resultobj = SWIG_Py_Void();
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37502 PyObject *resultobj = 0;
37503 wxWindow *result = 0 ;
37504
37505 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37506 {
37507 if (!wxPyCheckForApp()) SWIG_fail;
37508 PyThreadState* __tstate = wxPyBeginAllowThreads();
37509 result = (wxWindow *)wxWindow::GetCapture();
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 {
37514 resultobj = wxPyMake_wxObject(result, 0);
37515 }
37516 return resultobj;
37517 fail:
37518 return NULL;
37519 }
37520
37521
37522 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37523 PyObject *resultobj = 0;
37524 wxWindow *arg1 = (wxWindow *) 0 ;
37525 bool result;
37526 void *argp1 = 0 ;
37527 int res1 = 0 ;
37528 PyObject *swig_obj[1] ;
37529
37530 if (!args) SWIG_fail;
37531 swig_obj[0] = args;
37532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37533 if (!SWIG_IsOK(res1)) {
37534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37535 }
37536 arg1 = reinterpret_cast< wxWindow * >(argp1);
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (bool)((wxWindow const *)arg1)->HasCapture();
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_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 bool arg2 = (bool) true ;
37556 wxRect *arg3 = (wxRect *) NULL ;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 bool val2 ;
37560 int ecode2 = 0 ;
37561 void *argp3 = 0 ;
37562 int res3 = 0 ;
37563 PyObject * obj0 = 0 ;
37564 PyObject * obj1 = 0 ;
37565 PyObject * obj2 = 0 ;
37566 char * kwnames[] = {
37567 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37568 };
37569
37570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37574 }
37575 arg1 = reinterpret_cast< wxWindow * >(argp1);
37576 if (obj1) {
37577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37578 if (!SWIG_IsOK(ecode2)) {
37579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37580 }
37581 arg2 = static_cast< bool >(val2);
37582 }
37583 if (obj2) {
37584 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37585 if (!SWIG_IsOK(res3)) {
37586 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37587 }
37588 arg3 = reinterpret_cast< wxRect * >(argp3);
37589 }
37590 {
37591 PyThreadState* __tstate = wxPyBeginAllowThreads();
37592 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37593 wxPyEndAllowThreads(__tstate);
37594 if (PyErr_Occurred()) SWIG_fail;
37595 }
37596 resultobj = SWIG_Py_Void();
37597 return resultobj;
37598 fail:
37599 return NULL;
37600 }
37601
37602
37603 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37604 PyObject *resultobj = 0;
37605 wxWindow *arg1 = (wxWindow *) 0 ;
37606 wxRect *arg2 = 0 ;
37607 bool arg3 = (bool) true ;
37608 void *argp1 = 0 ;
37609 int res1 = 0 ;
37610 wxRect temp2 ;
37611 bool val3 ;
37612 int ecode3 = 0 ;
37613 PyObject * obj0 = 0 ;
37614 PyObject * obj1 = 0 ;
37615 PyObject * obj2 = 0 ;
37616 char * kwnames[] = {
37617 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37618 };
37619
37620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37622 if (!SWIG_IsOK(res1)) {
37623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37624 }
37625 arg1 = reinterpret_cast< wxWindow * >(argp1);
37626 {
37627 arg2 = &temp2;
37628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37629 }
37630 if (obj2) {
37631 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37632 if (!SWIG_IsOK(ecode3)) {
37633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37634 }
37635 arg3 = static_cast< bool >(val3);
37636 }
37637 {
37638 PyThreadState* __tstate = wxPyBeginAllowThreads();
37639 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37640 wxPyEndAllowThreads(__tstate);
37641 if (PyErr_Occurred()) SWIG_fail;
37642 }
37643 resultobj = SWIG_Py_Void();
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37651 PyObject *resultobj = 0;
37652 wxWindow *arg1 = (wxWindow *) 0 ;
37653 void *argp1 = 0 ;
37654 int res1 = 0 ;
37655 PyObject *swig_obj[1] ;
37656
37657 if (!args) SWIG_fail;
37658 swig_obj[0] = args;
37659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37660 if (!SWIG_IsOK(res1)) {
37661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37662 }
37663 arg1 = reinterpret_cast< wxWindow * >(argp1);
37664 {
37665 PyThreadState* __tstate = wxPyBeginAllowThreads();
37666 (arg1)->Update();
37667 wxPyEndAllowThreads(__tstate);
37668 if (PyErr_Occurred()) SWIG_fail;
37669 }
37670 resultobj = SWIG_Py_Void();
37671 return resultobj;
37672 fail:
37673 return NULL;
37674 }
37675
37676
37677 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37678 PyObject *resultobj = 0;
37679 wxWindow *arg1 = (wxWindow *) 0 ;
37680 void *argp1 = 0 ;
37681 int res1 = 0 ;
37682 PyObject *swig_obj[1] ;
37683
37684 if (!args) SWIG_fail;
37685 swig_obj[0] = args;
37686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37687 if (!SWIG_IsOK(res1)) {
37688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37689 }
37690 arg1 = reinterpret_cast< wxWindow * >(argp1);
37691 {
37692 PyThreadState* __tstate = wxPyBeginAllowThreads();
37693 (arg1)->ClearBackground();
37694 wxPyEndAllowThreads(__tstate);
37695 if (PyErr_Occurred()) SWIG_fail;
37696 }
37697 resultobj = SWIG_Py_Void();
37698 return resultobj;
37699 fail:
37700 return NULL;
37701 }
37702
37703
37704 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37705 PyObject *resultobj = 0;
37706 wxWindow *arg1 = (wxWindow *) 0 ;
37707 void *argp1 = 0 ;
37708 int res1 = 0 ;
37709 PyObject *swig_obj[1] ;
37710
37711 if (!args) SWIG_fail;
37712 swig_obj[0] = args;
37713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37714 if (!SWIG_IsOK(res1)) {
37715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37716 }
37717 arg1 = reinterpret_cast< wxWindow * >(argp1);
37718 {
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 (arg1)->Freeze();
37721 wxPyEndAllowThreads(__tstate);
37722 if (PyErr_Occurred()) SWIG_fail;
37723 }
37724 resultobj = SWIG_Py_Void();
37725 return resultobj;
37726 fail:
37727 return NULL;
37728 }
37729
37730
37731 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37732 PyObject *resultobj = 0;
37733 wxWindow *arg1 = (wxWindow *) 0 ;
37734 bool result;
37735 void *argp1 = 0 ;
37736 int res1 = 0 ;
37737 PyObject *swig_obj[1] ;
37738
37739 if (!args) SWIG_fail;
37740 swig_obj[0] = args;
37741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37742 if (!SWIG_IsOK(res1)) {
37743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37744 }
37745 arg1 = reinterpret_cast< wxWindow * >(argp1);
37746 {
37747 PyThreadState* __tstate = wxPyBeginAllowThreads();
37748 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37749 wxPyEndAllowThreads(__tstate);
37750 if (PyErr_Occurred()) SWIG_fail;
37751 }
37752 {
37753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37754 }
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37762 PyObject *resultobj = 0;
37763 wxWindow *arg1 = (wxWindow *) 0 ;
37764 void *argp1 = 0 ;
37765 int res1 = 0 ;
37766 PyObject *swig_obj[1] ;
37767
37768 if (!args) SWIG_fail;
37769 swig_obj[0] = args;
37770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37771 if (!SWIG_IsOK(res1)) {
37772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37773 }
37774 arg1 = reinterpret_cast< wxWindow * >(argp1);
37775 {
37776 PyThreadState* __tstate = wxPyBeginAllowThreads();
37777 (arg1)->Thaw();
37778 wxPyEndAllowThreads(__tstate);
37779 if (PyErr_Occurred()) SWIG_fail;
37780 }
37781 resultobj = SWIG_Py_Void();
37782 return resultobj;
37783 fail:
37784 return NULL;
37785 }
37786
37787
37788 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37789 PyObject *resultobj = 0;
37790 wxWindow *arg1 = (wxWindow *) 0 ;
37791 wxDC *arg2 = 0 ;
37792 void *argp1 = 0 ;
37793 int res1 = 0 ;
37794 void *argp2 = 0 ;
37795 int res2 = 0 ;
37796 PyObject * obj0 = 0 ;
37797 PyObject * obj1 = 0 ;
37798 char * kwnames[] = {
37799 (char *) "self",(char *) "dc", NULL
37800 };
37801
37802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37804 if (!SWIG_IsOK(res1)) {
37805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37806 }
37807 arg1 = reinterpret_cast< wxWindow * >(argp1);
37808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37809 if (!SWIG_IsOK(res2)) {
37810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37811 }
37812 if (!argp2) {
37813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37814 }
37815 arg2 = reinterpret_cast< wxDC * >(argp2);
37816 {
37817 PyThreadState* __tstate = wxPyBeginAllowThreads();
37818 (arg1)->PrepareDC(*arg2);
37819 wxPyEndAllowThreads(__tstate);
37820 if (PyErr_Occurred()) SWIG_fail;
37821 }
37822 resultobj = SWIG_Py_Void();
37823 return resultobj;
37824 fail:
37825 return NULL;
37826 }
37827
37828
37829 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37830 PyObject *resultobj = 0;
37831 wxWindow *arg1 = (wxWindow *) 0 ;
37832 bool result;
37833 void *argp1 = 0 ;
37834 int res1 = 0 ;
37835 PyObject *swig_obj[1] ;
37836
37837 if (!args) SWIG_fail;
37838 swig_obj[0] = args;
37839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37840 if (!SWIG_IsOK(res1)) {
37841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37842 }
37843 arg1 = reinterpret_cast< wxWindow * >(argp1);
37844 {
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 {
37851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37852 }
37853 return resultobj;
37854 fail:
37855 return NULL;
37856 }
37857
37858
37859 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37860 PyObject *resultobj = 0;
37861 wxWindow *arg1 = (wxWindow *) 0 ;
37862 wxRegion *result = 0 ;
37863 void *argp1 = 0 ;
37864 int res1 = 0 ;
37865 PyObject *swig_obj[1] ;
37866
37867 if (!args) SWIG_fail;
37868 swig_obj[0] = args;
37869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37870 if (!SWIG_IsOK(res1)) {
37871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37872 }
37873 arg1 = reinterpret_cast< wxWindow * >(argp1);
37874 {
37875 PyThreadState* __tstate = wxPyBeginAllowThreads();
37876 {
37877 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37878 result = (wxRegion *) &_result_ref;
37879 }
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxWindow *arg1 = (wxWindow *) 0 ;
37893 wxRect result;
37894 void *argp1 = 0 ;
37895 int res1 = 0 ;
37896 PyObject *swig_obj[1] ;
37897
37898 if (!args) SWIG_fail;
37899 swig_obj[0] = args;
37900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37901 if (!SWIG_IsOK(res1)) {
37902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37903 }
37904 arg1 = reinterpret_cast< wxWindow * >(argp1);
37905 {
37906 PyThreadState* __tstate = wxPyBeginAllowThreads();
37907 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37908 wxPyEndAllowThreads(__tstate);
37909 if (PyErr_Occurred()) SWIG_fail;
37910 }
37911 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj = 0;
37920 wxWindow *arg1 = (wxWindow *) 0 ;
37921 int arg2 ;
37922 int arg3 ;
37923 int arg4 = (int) 1 ;
37924 int arg5 = (int) 1 ;
37925 bool result;
37926 void *argp1 = 0 ;
37927 int res1 = 0 ;
37928 int val2 ;
37929 int ecode2 = 0 ;
37930 int val3 ;
37931 int ecode3 = 0 ;
37932 int val4 ;
37933 int ecode4 = 0 ;
37934 int val5 ;
37935 int ecode5 = 0 ;
37936 PyObject * obj0 = 0 ;
37937 PyObject * obj1 = 0 ;
37938 PyObject * obj2 = 0 ;
37939 PyObject * obj3 = 0 ;
37940 PyObject * obj4 = 0 ;
37941 char * kwnames[] = {
37942 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37943 };
37944
37945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37947 if (!SWIG_IsOK(res1)) {
37948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37949 }
37950 arg1 = reinterpret_cast< wxWindow * >(argp1);
37951 ecode2 = SWIG_AsVal_int(obj1, &val2);
37952 if (!SWIG_IsOK(ecode2)) {
37953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37954 }
37955 arg2 = static_cast< int >(val2);
37956 ecode3 = SWIG_AsVal_int(obj2, &val3);
37957 if (!SWIG_IsOK(ecode3)) {
37958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37959 }
37960 arg3 = static_cast< int >(val3);
37961 if (obj3) {
37962 ecode4 = SWIG_AsVal_int(obj3, &val4);
37963 if (!SWIG_IsOK(ecode4)) {
37964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37965 }
37966 arg4 = static_cast< int >(val4);
37967 }
37968 if (obj4) {
37969 ecode5 = SWIG_AsVal_int(obj4, &val5);
37970 if (!SWIG_IsOK(ecode5)) {
37971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37972 }
37973 arg5 = static_cast< int >(val5);
37974 }
37975 {
37976 PyThreadState* __tstate = wxPyBeginAllowThreads();
37977 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37978 wxPyEndAllowThreads(__tstate);
37979 if (PyErr_Occurred()) SWIG_fail;
37980 }
37981 {
37982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37983 }
37984 return resultobj;
37985 fail:
37986 return NULL;
37987 }
37988
37989
37990 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37991 PyObject *resultobj = 0;
37992 wxWindow *arg1 = (wxWindow *) 0 ;
37993 wxPoint *arg2 = 0 ;
37994 bool result;
37995 void *argp1 = 0 ;
37996 int res1 = 0 ;
37997 wxPoint temp2 ;
37998 PyObject * obj0 = 0 ;
37999 PyObject * obj1 = 0 ;
38000 char * kwnames[] = {
38001 (char *) "self",(char *) "pt", NULL
38002 };
38003
38004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38006 if (!SWIG_IsOK(res1)) {
38007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38008 }
38009 arg1 = reinterpret_cast< wxWindow * >(argp1);
38010 {
38011 arg2 = &temp2;
38012 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38013 }
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 {
38021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38022 }
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj = 0;
38031 wxWindow *arg1 = (wxWindow *) 0 ;
38032 wxRect *arg2 = 0 ;
38033 bool result;
38034 void *argp1 = 0 ;
38035 int res1 = 0 ;
38036 wxRect temp2 ;
38037 PyObject * obj0 = 0 ;
38038 PyObject * obj1 = 0 ;
38039 char * kwnames[] = {
38040 (char *) "self",(char *) "rect", NULL
38041 };
38042
38043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38045 if (!SWIG_IsOK(res1)) {
38046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38047 }
38048 arg1 = reinterpret_cast< wxWindow * >(argp1);
38049 {
38050 arg2 = &temp2;
38051 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38052 }
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38069 PyObject *resultobj = 0;
38070 wxWindow *arg1 = (wxWindow *) 0 ;
38071 SwigValueWrapper<wxVisualAttributes > result;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 PyObject *swig_obj[1] ;
38075
38076 if (!args) SWIG_fail;
38077 swig_obj[0] = args;
38078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38079 if (!SWIG_IsOK(res1)) {
38080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38081 }
38082 arg1 = reinterpret_cast< wxWindow * >(argp1);
38083 {
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38090 return resultobj;
38091 fail:
38092 return NULL;
38093 }
38094
38095
38096 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38097 PyObject *resultobj = 0;
38098 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38099 SwigValueWrapper<wxVisualAttributes > result;
38100 int val1 ;
38101 int ecode1 = 0 ;
38102 PyObject * obj0 = 0 ;
38103 char * kwnames[] = {
38104 (char *) "variant", NULL
38105 };
38106
38107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38108 if (obj0) {
38109 ecode1 = SWIG_AsVal_int(obj0, &val1);
38110 if (!SWIG_IsOK(ecode1)) {
38111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38112 }
38113 arg1 = static_cast< wxWindowVariant >(val1);
38114 }
38115 {
38116 if (!wxPyCheckForApp()) SWIG_fail;
38117 PyThreadState* __tstate = wxPyBeginAllowThreads();
38118 result = wxWindow::GetClassDefaultAttributes(arg1);
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38123 return resultobj;
38124 fail:
38125 return NULL;
38126 }
38127
38128
38129 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38130 PyObject *resultobj = 0;
38131 wxWindow *arg1 = (wxWindow *) 0 ;
38132 wxColour *arg2 = 0 ;
38133 bool result;
38134 void *argp1 = 0 ;
38135 int res1 = 0 ;
38136 wxColour temp2 ;
38137 PyObject * obj0 = 0 ;
38138 PyObject * obj1 = 0 ;
38139 char * kwnames[] = {
38140 (char *) "self",(char *) "colour", NULL
38141 };
38142
38143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38145 if (!SWIG_IsOK(res1)) {
38146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38147 }
38148 arg1 = reinterpret_cast< wxWindow * >(argp1);
38149 {
38150 arg2 = &temp2;
38151 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38152 }
38153 {
38154 PyThreadState* __tstate = wxPyBeginAllowThreads();
38155 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38156 wxPyEndAllowThreads(__tstate);
38157 if (PyErr_Occurred()) SWIG_fail;
38158 }
38159 {
38160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38161 }
38162 return resultobj;
38163 fail:
38164 return NULL;
38165 }
38166
38167
38168 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38169 PyObject *resultobj = 0;
38170 wxWindow *arg1 = (wxWindow *) 0 ;
38171 wxColour *arg2 = 0 ;
38172 void *argp1 = 0 ;
38173 int res1 = 0 ;
38174 wxColour temp2 ;
38175 PyObject * obj0 = 0 ;
38176 PyObject * obj1 = 0 ;
38177 char * kwnames[] = {
38178 (char *) "self",(char *) "colour", NULL
38179 };
38180
38181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38183 if (!SWIG_IsOK(res1)) {
38184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38185 }
38186 arg1 = reinterpret_cast< wxWindow * >(argp1);
38187 {
38188 arg2 = &temp2;
38189 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38190 }
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38194 wxPyEndAllowThreads(__tstate);
38195 if (PyErr_Occurred()) SWIG_fail;
38196 }
38197 resultobj = SWIG_Py_Void();
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38205 PyObject *resultobj = 0;
38206 wxWindow *arg1 = (wxWindow *) 0 ;
38207 wxColour *arg2 = 0 ;
38208 bool result;
38209 void *argp1 = 0 ;
38210 int res1 = 0 ;
38211 wxColour temp2 ;
38212 PyObject * obj0 = 0 ;
38213 PyObject * obj1 = 0 ;
38214 char * kwnames[] = {
38215 (char *) "self",(char *) "colour", NULL
38216 };
38217
38218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38220 if (!SWIG_IsOK(res1)) {
38221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38222 }
38223 arg1 = reinterpret_cast< wxWindow * >(argp1);
38224 {
38225 arg2 = &temp2;
38226 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38227 }
38228 {
38229 PyThreadState* __tstate = wxPyBeginAllowThreads();
38230 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 {
38235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38236 }
38237 return resultobj;
38238 fail:
38239 return NULL;
38240 }
38241
38242
38243 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38244 PyObject *resultobj = 0;
38245 wxWindow *arg1 = (wxWindow *) 0 ;
38246 wxColour *arg2 = 0 ;
38247 void *argp1 = 0 ;
38248 int res1 = 0 ;
38249 wxColour temp2 ;
38250 PyObject * obj0 = 0 ;
38251 PyObject * obj1 = 0 ;
38252 char * kwnames[] = {
38253 (char *) "self",(char *) "colour", NULL
38254 };
38255
38256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38258 if (!SWIG_IsOK(res1)) {
38259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38260 }
38261 arg1 = reinterpret_cast< wxWindow * >(argp1);
38262 {
38263 arg2 = &temp2;
38264 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38265 }
38266 {
38267 PyThreadState* __tstate = wxPyBeginAllowThreads();
38268 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 resultobj = SWIG_Py_Void();
38273 return resultobj;
38274 fail:
38275 return NULL;
38276 }
38277
38278
38279 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38280 PyObject *resultobj = 0;
38281 wxWindow *arg1 = (wxWindow *) 0 ;
38282 wxColour result;
38283 void *argp1 = 0 ;
38284 int res1 = 0 ;
38285 PyObject *swig_obj[1] ;
38286
38287 if (!args) SWIG_fail;
38288 swig_obj[0] = args;
38289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38290 if (!SWIG_IsOK(res1)) {
38291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38292 }
38293 arg1 = reinterpret_cast< wxWindow * >(argp1);
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38297 wxPyEndAllowThreads(__tstate);
38298 if (PyErr_Occurred()) SWIG_fail;
38299 }
38300 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38308 PyObject *resultobj = 0;
38309 wxWindow *arg1 = (wxWindow *) 0 ;
38310 wxColour result;
38311 void *argp1 = 0 ;
38312 int res1 = 0 ;
38313 PyObject *swig_obj[1] ;
38314
38315 if (!args) SWIG_fail;
38316 swig_obj[0] = args;
38317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38318 if (!SWIG_IsOK(res1)) {
38319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38320 }
38321 arg1 = reinterpret_cast< wxWindow * >(argp1);
38322 {
38323 PyThreadState* __tstate = wxPyBeginAllowThreads();
38324 result = ((wxWindow const *)arg1)->GetForegroundColour();
38325 wxPyEndAllowThreads(__tstate);
38326 if (PyErr_Occurred()) SWIG_fail;
38327 }
38328 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38329 return resultobj;
38330 fail:
38331 return NULL;
38332 }
38333
38334
38335 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38336 PyObject *resultobj = 0;
38337 wxWindow *arg1 = (wxWindow *) 0 ;
38338 bool result;
38339 void *argp1 = 0 ;
38340 int res1 = 0 ;
38341 PyObject *swig_obj[1] ;
38342
38343 if (!args) SWIG_fail;
38344 swig_obj[0] = args;
38345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38346 if (!SWIG_IsOK(res1)) {
38347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38348 }
38349 arg1 = reinterpret_cast< wxWindow * >(argp1);
38350 {
38351 PyThreadState* __tstate = wxPyBeginAllowThreads();
38352 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38353 wxPyEndAllowThreads(__tstate);
38354 if (PyErr_Occurred()) SWIG_fail;
38355 }
38356 {
38357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38358 }
38359 return resultobj;
38360 fail:
38361 return NULL;
38362 }
38363
38364
38365 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38366 PyObject *resultobj = 0;
38367 wxWindow *arg1 = (wxWindow *) 0 ;
38368 bool result;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 PyObject *swig_obj[1] ;
38372
38373 if (!args) SWIG_fail;
38374 swig_obj[0] = args;
38375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38376 if (!SWIG_IsOK(res1)) {
38377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38378 }
38379 arg1 = reinterpret_cast< wxWindow * >(argp1);
38380 {
38381 PyThreadState* __tstate = wxPyBeginAllowThreads();
38382 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38383 wxPyEndAllowThreads(__tstate);
38384 if (PyErr_Occurred()) SWIG_fail;
38385 }
38386 {
38387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38388 }
38389 return resultobj;
38390 fail:
38391 return NULL;
38392 }
38393
38394
38395 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj = 0;
38397 wxWindow *arg1 = (wxWindow *) 0 ;
38398 wxBackgroundStyle arg2 ;
38399 bool result;
38400 void *argp1 = 0 ;
38401 int res1 = 0 ;
38402 int val2 ;
38403 int ecode2 = 0 ;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 char * kwnames[] = {
38407 (char *) "self",(char *) "style", NULL
38408 };
38409
38410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38412 if (!SWIG_IsOK(res1)) {
38413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38414 }
38415 arg1 = reinterpret_cast< wxWindow * >(argp1);
38416 ecode2 = SWIG_AsVal_int(obj1, &val2);
38417 if (!SWIG_IsOK(ecode2)) {
38418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38419 }
38420 arg2 = static_cast< wxBackgroundStyle >(val2);
38421 {
38422 PyThreadState* __tstate = wxPyBeginAllowThreads();
38423 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38424 wxPyEndAllowThreads(__tstate);
38425 if (PyErr_Occurred()) SWIG_fail;
38426 }
38427 {
38428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38429 }
38430 return resultobj;
38431 fail:
38432 return NULL;
38433 }
38434
38435
38436 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38437 PyObject *resultobj = 0;
38438 wxWindow *arg1 = (wxWindow *) 0 ;
38439 wxBackgroundStyle result;
38440 void *argp1 = 0 ;
38441 int res1 = 0 ;
38442 PyObject *swig_obj[1] ;
38443
38444 if (!args) SWIG_fail;
38445 swig_obj[0] = args;
38446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38447 if (!SWIG_IsOK(res1)) {
38448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38449 }
38450 arg1 = reinterpret_cast< wxWindow * >(argp1);
38451 {
38452 PyThreadState* __tstate = wxPyBeginAllowThreads();
38453 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38454 wxPyEndAllowThreads(__tstate);
38455 if (PyErr_Occurred()) SWIG_fail;
38456 }
38457 resultobj = SWIG_From_int(static_cast< int >(result));
38458 return resultobj;
38459 fail:
38460 return NULL;
38461 }
38462
38463
38464 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38465 PyObject *resultobj = 0;
38466 wxWindow *arg1 = (wxWindow *) 0 ;
38467 bool result;
38468 void *argp1 = 0 ;
38469 int res1 = 0 ;
38470 PyObject *swig_obj[1] ;
38471
38472 if (!args) SWIG_fail;
38473 swig_obj[0] = args;
38474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38475 if (!SWIG_IsOK(res1)) {
38476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38477 }
38478 arg1 = reinterpret_cast< wxWindow * >(argp1);
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 result = (bool)(arg1)->HasTransparentBackground();
38482 wxPyEndAllowThreads(__tstate);
38483 if (PyErr_Occurred()) SWIG_fail;
38484 }
38485 {
38486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38487 }
38488 return resultobj;
38489 fail:
38490 return NULL;
38491 }
38492
38493
38494 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38495 PyObject *resultobj = 0;
38496 wxWindow *arg1 = (wxWindow *) 0 ;
38497 wxCursor *arg2 = 0 ;
38498 bool result;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 void *argp2 = 0 ;
38502 int res2 = 0 ;
38503 PyObject * obj0 = 0 ;
38504 PyObject * obj1 = 0 ;
38505 char * kwnames[] = {
38506 (char *) "self",(char *) "cursor", NULL
38507 };
38508
38509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38511 if (!SWIG_IsOK(res1)) {
38512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38513 }
38514 arg1 = reinterpret_cast< wxWindow * >(argp1);
38515 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38516 if (!SWIG_IsOK(res2)) {
38517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38518 }
38519 if (!argp2) {
38520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38521 }
38522 arg2 = reinterpret_cast< wxCursor * >(argp2);
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38526 wxPyEndAllowThreads(__tstate);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 }
38529 {
38530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38531 }
38532 return resultobj;
38533 fail:
38534 return NULL;
38535 }
38536
38537
38538 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38539 PyObject *resultobj = 0;
38540 wxWindow *arg1 = (wxWindow *) 0 ;
38541 wxCursor result;
38542 void *argp1 = 0 ;
38543 int res1 = 0 ;
38544 PyObject *swig_obj[1] ;
38545
38546 if (!args) SWIG_fail;
38547 swig_obj[0] = args;
38548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38549 if (!SWIG_IsOK(res1)) {
38550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38551 }
38552 arg1 = reinterpret_cast< wxWindow * >(argp1);
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 result = (arg1)->GetCursor();
38556 wxPyEndAllowThreads(__tstate);
38557 if (PyErr_Occurred()) SWIG_fail;
38558 }
38559 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38560 return resultobj;
38561 fail:
38562 return NULL;
38563 }
38564
38565
38566 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38567 PyObject *resultobj = 0;
38568 wxWindow *arg1 = (wxWindow *) 0 ;
38569 wxFont *arg2 = 0 ;
38570 bool result;
38571 void *argp1 = 0 ;
38572 int res1 = 0 ;
38573 void *argp2 = 0 ;
38574 int res2 = 0 ;
38575 PyObject * obj0 = 0 ;
38576 PyObject * obj1 = 0 ;
38577 char * kwnames[] = {
38578 (char *) "self",(char *) "font", NULL
38579 };
38580
38581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38583 if (!SWIG_IsOK(res1)) {
38584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38585 }
38586 arg1 = reinterpret_cast< wxWindow * >(argp1);
38587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38588 if (!SWIG_IsOK(res2)) {
38589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38590 }
38591 if (!argp2) {
38592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38593 }
38594 arg2 = reinterpret_cast< wxFont * >(argp2);
38595 {
38596 PyThreadState* __tstate = wxPyBeginAllowThreads();
38597 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38598 wxPyEndAllowThreads(__tstate);
38599 if (PyErr_Occurred()) SWIG_fail;
38600 }
38601 {
38602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38603 }
38604 return resultobj;
38605 fail:
38606 return NULL;
38607 }
38608
38609
38610 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38611 PyObject *resultobj = 0;
38612 wxWindow *arg1 = (wxWindow *) 0 ;
38613 wxFont *arg2 = 0 ;
38614 void *argp1 = 0 ;
38615 int res1 = 0 ;
38616 void *argp2 = 0 ;
38617 int res2 = 0 ;
38618 PyObject * obj0 = 0 ;
38619 PyObject * obj1 = 0 ;
38620 char * kwnames[] = {
38621 (char *) "self",(char *) "font", NULL
38622 };
38623
38624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38628 }
38629 arg1 = reinterpret_cast< wxWindow * >(argp1);
38630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38631 if (!SWIG_IsOK(res2)) {
38632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38633 }
38634 if (!argp2) {
38635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38636 }
38637 arg2 = reinterpret_cast< wxFont * >(argp2);
38638 {
38639 PyThreadState* __tstate = wxPyBeginAllowThreads();
38640 (arg1)->SetOwnFont((wxFont const &)*arg2);
38641 wxPyEndAllowThreads(__tstate);
38642 if (PyErr_Occurred()) SWIG_fail;
38643 }
38644 resultobj = SWIG_Py_Void();
38645 return resultobj;
38646 fail:
38647 return NULL;
38648 }
38649
38650
38651 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38652 PyObject *resultobj = 0;
38653 wxWindow *arg1 = (wxWindow *) 0 ;
38654 wxFont result;
38655 void *argp1 = 0 ;
38656 int res1 = 0 ;
38657 PyObject *swig_obj[1] ;
38658
38659 if (!args) SWIG_fail;
38660 swig_obj[0] = args;
38661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38662 if (!SWIG_IsOK(res1)) {
38663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38664 }
38665 arg1 = reinterpret_cast< wxWindow * >(argp1);
38666 {
38667 PyThreadState* __tstate = wxPyBeginAllowThreads();
38668 result = (arg1)->GetFont();
38669 wxPyEndAllowThreads(__tstate);
38670 if (PyErr_Occurred()) SWIG_fail;
38671 }
38672 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38673 return resultobj;
38674 fail:
38675 return NULL;
38676 }
38677
38678
38679 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38680 PyObject *resultobj = 0;
38681 wxWindow *arg1 = (wxWindow *) 0 ;
38682 wxCaret *arg2 = (wxCaret *) 0 ;
38683 void *argp1 = 0 ;
38684 int res1 = 0 ;
38685 int res2 = 0 ;
38686 PyObject * obj0 = 0 ;
38687 PyObject * obj1 = 0 ;
38688 char * kwnames[] = {
38689 (char *) "self",(char *) "caret", NULL
38690 };
38691
38692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38694 if (!SWIG_IsOK(res1)) {
38695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38696 }
38697 arg1 = reinterpret_cast< wxWindow * >(argp1);
38698 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38699 if (!SWIG_IsOK(res2)) {
38700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38701 }
38702 {
38703 PyThreadState* __tstate = wxPyBeginAllowThreads();
38704 (arg1)->SetCaret(arg2);
38705 wxPyEndAllowThreads(__tstate);
38706 if (PyErr_Occurred()) SWIG_fail;
38707 }
38708 resultobj = SWIG_Py_Void();
38709 return resultobj;
38710 fail:
38711 return NULL;
38712 }
38713
38714
38715 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38716 PyObject *resultobj = 0;
38717 wxWindow *arg1 = (wxWindow *) 0 ;
38718 wxCaret *result = 0 ;
38719 void *argp1 = 0 ;
38720 int res1 = 0 ;
38721 PyObject *swig_obj[1] ;
38722
38723 if (!args) SWIG_fail;
38724 swig_obj[0] = args;
38725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38726 if (!SWIG_IsOK(res1)) {
38727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38728 }
38729 arg1 = reinterpret_cast< wxWindow * >(argp1);
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38733 wxPyEndAllowThreads(__tstate);
38734 if (PyErr_Occurred()) SWIG_fail;
38735 }
38736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38737 return resultobj;
38738 fail:
38739 return NULL;
38740 }
38741
38742
38743 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38744 PyObject *resultobj = 0;
38745 wxWindow *arg1 = (wxWindow *) 0 ;
38746 int result;
38747 void *argp1 = 0 ;
38748 int res1 = 0 ;
38749 PyObject *swig_obj[1] ;
38750
38751 if (!args) SWIG_fail;
38752 swig_obj[0] = args;
38753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38754 if (!SWIG_IsOK(res1)) {
38755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38756 }
38757 arg1 = reinterpret_cast< wxWindow * >(argp1);
38758 {
38759 PyThreadState* __tstate = wxPyBeginAllowThreads();
38760 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38761 wxPyEndAllowThreads(__tstate);
38762 if (PyErr_Occurred()) SWIG_fail;
38763 }
38764 resultobj = SWIG_From_int(static_cast< int >(result));
38765 return resultobj;
38766 fail:
38767 return NULL;
38768 }
38769
38770
38771 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38772 PyObject *resultobj = 0;
38773 wxWindow *arg1 = (wxWindow *) 0 ;
38774 int result;
38775 void *argp1 = 0 ;
38776 int res1 = 0 ;
38777 PyObject *swig_obj[1] ;
38778
38779 if (!args) SWIG_fail;
38780 swig_obj[0] = args;
38781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38782 if (!SWIG_IsOK(res1)) {
38783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38784 }
38785 arg1 = reinterpret_cast< wxWindow * >(argp1);
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 resultobj = SWIG_From_int(static_cast< int >(result));
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38800 PyObject *resultobj = 0;
38801 wxWindow *arg1 = (wxWindow *) 0 ;
38802 wxString *arg2 = 0 ;
38803 int *arg3 = (int *) 0 ;
38804 int *arg4 = (int *) 0 ;
38805 void *argp1 = 0 ;
38806 int res1 = 0 ;
38807 bool temp2 = false ;
38808 int temp3 ;
38809 int res3 = SWIG_TMPOBJ ;
38810 int temp4 ;
38811 int res4 = SWIG_TMPOBJ ;
38812 PyObject * obj0 = 0 ;
38813 PyObject * obj1 = 0 ;
38814 char * kwnames[] = {
38815 (char *) "self",(char *) "string", NULL
38816 };
38817
38818 arg3 = &temp3;
38819 arg4 = &temp4;
38820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38822 if (!SWIG_IsOK(res1)) {
38823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38824 }
38825 arg1 = reinterpret_cast< wxWindow * >(argp1);
38826 {
38827 arg2 = wxString_in_helper(obj1);
38828 if (arg2 == NULL) SWIG_fail;
38829 temp2 = true;
38830 }
38831 {
38832 PyThreadState* __tstate = wxPyBeginAllowThreads();
38833 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38834 wxPyEndAllowThreads(__tstate);
38835 if (PyErr_Occurred()) SWIG_fail;
38836 }
38837 resultobj = SWIG_Py_Void();
38838 if (SWIG_IsTmpObj(res3)) {
38839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38840 } else {
38841 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38843 }
38844 if (SWIG_IsTmpObj(res4)) {
38845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38846 } else {
38847 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38849 }
38850 {
38851 if (temp2)
38852 delete arg2;
38853 }
38854 return resultobj;
38855 fail:
38856 {
38857 if (temp2)
38858 delete arg2;
38859 }
38860 return NULL;
38861 }
38862
38863
38864 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj = 0;
38866 wxWindow *arg1 = (wxWindow *) 0 ;
38867 wxString *arg2 = 0 ;
38868 int *arg3 = (int *) 0 ;
38869 int *arg4 = (int *) 0 ;
38870 int *arg5 = (int *) 0 ;
38871 int *arg6 = (int *) 0 ;
38872 wxFont *arg7 = (wxFont *) NULL ;
38873 void *argp1 = 0 ;
38874 int res1 = 0 ;
38875 bool temp2 = false ;
38876 int temp3 ;
38877 int res3 = SWIG_TMPOBJ ;
38878 int temp4 ;
38879 int res4 = SWIG_TMPOBJ ;
38880 int temp5 ;
38881 int res5 = SWIG_TMPOBJ ;
38882 int temp6 ;
38883 int res6 = SWIG_TMPOBJ ;
38884 void *argp7 = 0 ;
38885 int res7 = 0 ;
38886 PyObject * obj0 = 0 ;
38887 PyObject * obj1 = 0 ;
38888 PyObject * obj2 = 0 ;
38889 char * kwnames[] = {
38890 (char *) "self",(char *) "string",(char *) "font", NULL
38891 };
38892
38893 arg3 = &temp3;
38894 arg4 = &temp4;
38895 arg5 = &temp5;
38896 arg6 = &temp6;
38897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38899 if (!SWIG_IsOK(res1)) {
38900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38901 }
38902 arg1 = reinterpret_cast< wxWindow * >(argp1);
38903 {
38904 arg2 = wxString_in_helper(obj1);
38905 if (arg2 == NULL) SWIG_fail;
38906 temp2 = true;
38907 }
38908 if (obj2) {
38909 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38910 if (!SWIG_IsOK(res7)) {
38911 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38912 }
38913 arg7 = reinterpret_cast< wxFont * >(argp7);
38914 }
38915 {
38916 PyThreadState* __tstate = wxPyBeginAllowThreads();
38917 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38918 wxPyEndAllowThreads(__tstate);
38919 if (PyErr_Occurred()) SWIG_fail;
38920 }
38921 resultobj = SWIG_Py_Void();
38922 if (SWIG_IsTmpObj(res3)) {
38923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38924 } else {
38925 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38927 }
38928 if (SWIG_IsTmpObj(res4)) {
38929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38930 } else {
38931 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38933 }
38934 if (SWIG_IsTmpObj(res5)) {
38935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38936 } else {
38937 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38939 }
38940 if (SWIG_IsTmpObj(res6)) {
38941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38942 } else {
38943 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38945 }
38946 {
38947 if (temp2)
38948 delete arg2;
38949 }
38950 return resultobj;
38951 fail:
38952 {
38953 if (temp2)
38954 delete arg2;
38955 }
38956 return NULL;
38957 }
38958
38959
38960 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38961 PyObject *resultobj = 0;
38962 wxWindow *arg1 = (wxWindow *) 0 ;
38963 int *arg2 = (int *) 0 ;
38964 int *arg3 = (int *) 0 ;
38965 void *argp1 = 0 ;
38966 int res1 = 0 ;
38967 int temp2 ;
38968 int res2 = 0 ;
38969 int temp3 ;
38970 int res3 = 0 ;
38971 PyObject * obj0 = 0 ;
38972 PyObject * obj1 = 0 ;
38973 PyObject * obj2 = 0 ;
38974 char * kwnames[] = {
38975 (char *) "self",(char *) "x",(char *) "y", NULL
38976 };
38977
38978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38980 if (!SWIG_IsOK(res1)) {
38981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38982 }
38983 arg1 = reinterpret_cast< wxWindow * >(argp1);
38984 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38985 int val;
38986 int ecode = SWIG_AsVal_int(obj1, &val);
38987 if (!SWIG_IsOK(ecode)) {
38988 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38989 }
38990 temp2 = static_cast< int >(val);
38991 arg2 = &temp2;
38992 res2 = SWIG_AddTmpMask(ecode);
38993 }
38994 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38995 int val;
38996 int ecode = SWIG_AsVal_int(obj2, &val);
38997 if (!SWIG_IsOK(ecode)) {
38998 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38999 }
39000 temp3 = static_cast< int >(val);
39001 arg3 = &temp3;
39002 res3 = SWIG_AddTmpMask(ecode);
39003 }
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39007 wxPyEndAllowThreads(__tstate);
39008 if (PyErr_Occurred()) SWIG_fail;
39009 }
39010 resultobj = SWIG_Py_Void();
39011 if (SWIG_IsTmpObj(res2)) {
39012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39013 } else {
39014 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39016 }
39017 if (SWIG_IsTmpObj(res3)) {
39018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39019 } else {
39020 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39022 }
39023 return resultobj;
39024 fail:
39025 return NULL;
39026 }
39027
39028
39029 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39030 PyObject *resultobj = 0;
39031 wxWindow *arg1 = (wxWindow *) 0 ;
39032 int *arg2 = (int *) 0 ;
39033 int *arg3 = (int *) 0 ;
39034 void *argp1 = 0 ;
39035 int res1 = 0 ;
39036 int temp2 ;
39037 int res2 = 0 ;
39038 int temp3 ;
39039 int res3 = 0 ;
39040 PyObject * obj0 = 0 ;
39041 PyObject * obj1 = 0 ;
39042 PyObject * obj2 = 0 ;
39043 char * kwnames[] = {
39044 (char *) "self",(char *) "x",(char *) "y", NULL
39045 };
39046
39047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39049 if (!SWIG_IsOK(res1)) {
39050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39051 }
39052 arg1 = reinterpret_cast< wxWindow * >(argp1);
39053 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39054 int val;
39055 int ecode = SWIG_AsVal_int(obj1, &val);
39056 if (!SWIG_IsOK(ecode)) {
39057 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39058 }
39059 temp2 = static_cast< int >(val);
39060 arg2 = &temp2;
39061 res2 = SWIG_AddTmpMask(ecode);
39062 }
39063 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39064 int val;
39065 int ecode = SWIG_AsVal_int(obj2, &val);
39066 if (!SWIG_IsOK(ecode)) {
39067 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39068 }
39069 temp3 = static_cast< int >(val);
39070 arg3 = &temp3;
39071 res3 = SWIG_AddTmpMask(ecode);
39072 }
39073 {
39074 PyThreadState* __tstate = wxPyBeginAllowThreads();
39075 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39076 wxPyEndAllowThreads(__tstate);
39077 if (PyErr_Occurred()) SWIG_fail;
39078 }
39079 resultobj = SWIG_Py_Void();
39080 if (SWIG_IsTmpObj(res2)) {
39081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39082 } else {
39083 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39085 }
39086 if (SWIG_IsTmpObj(res3)) {
39087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39088 } else {
39089 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39091 }
39092 return resultobj;
39093 fail:
39094 return NULL;
39095 }
39096
39097
39098 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39099 PyObject *resultobj = 0;
39100 wxWindow *arg1 = (wxWindow *) 0 ;
39101 wxPoint *arg2 = 0 ;
39102 wxPoint result;
39103 void *argp1 = 0 ;
39104 int res1 = 0 ;
39105 wxPoint temp2 ;
39106 PyObject * obj0 = 0 ;
39107 PyObject * obj1 = 0 ;
39108 char * kwnames[] = {
39109 (char *) "self",(char *) "pt", NULL
39110 };
39111
39112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39114 if (!SWIG_IsOK(res1)) {
39115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39116 }
39117 arg1 = reinterpret_cast< wxWindow * >(argp1);
39118 {
39119 arg2 = &temp2;
39120 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39121 }
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39125 wxPyEndAllowThreads(__tstate);
39126 if (PyErr_Occurred()) SWIG_fail;
39127 }
39128 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39129 return resultobj;
39130 fail:
39131 return NULL;
39132 }
39133
39134
39135 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj = 0;
39137 wxWindow *arg1 = (wxWindow *) 0 ;
39138 wxPoint *arg2 = 0 ;
39139 wxPoint result;
39140 void *argp1 = 0 ;
39141 int res1 = 0 ;
39142 wxPoint temp2 ;
39143 PyObject * obj0 = 0 ;
39144 PyObject * obj1 = 0 ;
39145 char * kwnames[] = {
39146 (char *) "self",(char *) "pt", NULL
39147 };
39148
39149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39151 if (!SWIG_IsOK(res1)) {
39152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39153 }
39154 arg1 = reinterpret_cast< wxWindow * >(argp1);
39155 {
39156 arg2 = &temp2;
39157 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39158 }
39159 {
39160 PyThreadState* __tstate = wxPyBeginAllowThreads();
39161 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39162 wxPyEndAllowThreads(__tstate);
39163 if (PyErr_Occurred()) SWIG_fail;
39164 }
39165 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39166 return resultobj;
39167 fail:
39168 return NULL;
39169 }
39170
39171
39172 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39173 PyObject *resultobj = 0;
39174 wxWindow *arg1 = (wxWindow *) 0 ;
39175 int arg2 ;
39176 int arg3 ;
39177 wxHitTest result;
39178 void *argp1 = 0 ;
39179 int res1 = 0 ;
39180 int val2 ;
39181 int ecode2 = 0 ;
39182 int val3 ;
39183 int ecode3 = 0 ;
39184 PyObject * obj0 = 0 ;
39185 PyObject * obj1 = 0 ;
39186 PyObject * obj2 = 0 ;
39187 char * kwnames[] = {
39188 (char *) "self",(char *) "x",(char *) "y", NULL
39189 };
39190
39191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39193 if (!SWIG_IsOK(res1)) {
39194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39195 }
39196 arg1 = reinterpret_cast< wxWindow * >(argp1);
39197 ecode2 = SWIG_AsVal_int(obj1, &val2);
39198 if (!SWIG_IsOK(ecode2)) {
39199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39200 }
39201 arg2 = static_cast< int >(val2);
39202 ecode3 = SWIG_AsVal_int(obj2, &val3);
39203 if (!SWIG_IsOK(ecode3)) {
39204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39205 }
39206 arg3 = static_cast< int >(val3);
39207 {
39208 PyThreadState* __tstate = wxPyBeginAllowThreads();
39209 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39210 wxPyEndAllowThreads(__tstate);
39211 if (PyErr_Occurred()) SWIG_fail;
39212 }
39213 resultobj = SWIG_From_int(static_cast< int >(result));
39214 return resultobj;
39215 fail:
39216 return NULL;
39217 }
39218
39219
39220 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj = 0;
39222 wxWindow *arg1 = (wxWindow *) 0 ;
39223 wxPoint *arg2 = 0 ;
39224 wxHitTest result;
39225 void *argp1 = 0 ;
39226 int res1 = 0 ;
39227 wxPoint temp2 ;
39228 PyObject * obj0 = 0 ;
39229 PyObject * obj1 = 0 ;
39230 char * kwnames[] = {
39231 (char *) "self",(char *) "pt", NULL
39232 };
39233
39234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39236 if (!SWIG_IsOK(res1)) {
39237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39238 }
39239 arg1 = reinterpret_cast< wxWindow * >(argp1);
39240 {
39241 arg2 = &temp2;
39242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39243 }
39244 {
39245 PyThreadState* __tstate = wxPyBeginAllowThreads();
39246 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39247 wxPyEndAllowThreads(__tstate);
39248 if (PyErr_Occurred()) SWIG_fail;
39249 }
39250 resultobj = SWIG_From_int(static_cast< int >(result));
39251 return resultobj;
39252 fail:
39253 return NULL;
39254 }
39255
39256
39257 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39258 PyObject *resultobj = 0;
39259 wxWindow *arg1 = (wxWindow *) 0 ;
39260 long arg2 ;
39261 wxBorder result;
39262 void *argp1 = 0 ;
39263 int res1 = 0 ;
39264 long val2 ;
39265 int ecode2 = 0 ;
39266
39267 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39269 if (!SWIG_IsOK(res1)) {
39270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39271 }
39272 arg1 = reinterpret_cast< wxWindow * >(argp1);
39273 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39274 if (!SWIG_IsOK(ecode2)) {
39275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39276 }
39277 arg2 = static_cast< long >(val2);
39278 {
39279 PyThreadState* __tstate = wxPyBeginAllowThreads();
39280 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 resultobj = SWIG_From_int(static_cast< int >(result));
39285 return resultobj;
39286 fail:
39287 return NULL;
39288 }
39289
39290
39291 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39292 PyObject *resultobj = 0;
39293 wxWindow *arg1 = (wxWindow *) 0 ;
39294 wxBorder result;
39295 void *argp1 = 0 ;
39296 int res1 = 0 ;
39297
39298 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39300 if (!SWIG_IsOK(res1)) {
39301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39302 }
39303 arg1 = reinterpret_cast< wxWindow * >(argp1);
39304 {
39305 PyThreadState* __tstate = wxPyBeginAllowThreads();
39306 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39307 wxPyEndAllowThreads(__tstate);
39308 if (PyErr_Occurred()) SWIG_fail;
39309 }
39310 resultobj = SWIG_From_int(static_cast< int >(result));
39311 return resultobj;
39312 fail:
39313 return NULL;
39314 }
39315
39316
39317 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39318 int argc;
39319 PyObject *argv[3];
39320
39321 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39322 --argc;
39323 if (argc == 1) {
39324 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39325 }
39326 if (argc == 2) {
39327 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39328 }
39329
39330 fail:
39331 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39332 return NULL;
39333 }
39334
39335
39336 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39337 PyObject *resultobj = 0;
39338 wxWindow *arg1 = (wxWindow *) 0 ;
39339 long arg2 = (long) wxUPDATE_UI_NONE ;
39340 void *argp1 = 0 ;
39341 int res1 = 0 ;
39342 long val2 ;
39343 int ecode2 = 0 ;
39344 PyObject * obj0 = 0 ;
39345 PyObject * obj1 = 0 ;
39346 char * kwnames[] = {
39347 (char *) "self",(char *) "flags", NULL
39348 };
39349
39350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39352 if (!SWIG_IsOK(res1)) {
39353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39354 }
39355 arg1 = reinterpret_cast< wxWindow * >(argp1);
39356 if (obj1) {
39357 ecode2 = SWIG_AsVal_long(obj1, &val2);
39358 if (!SWIG_IsOK(ecode2)) {
39359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39360 }
39361 arg2 = static_cast< long >(val2);
39362 }
39363 {
39364 PyThreadState* __tstate = wxPyBeginAllowThreads();
39365 (arg1)->UpdateWindowUI(arg2);
39366 wxPyEndAllowThreads(__tstate);
39367 if (PyErr_Occurred()) SWIG_fail;
39368 }
39369 resultobj = SWIG_Py_Void();
39370 return resultobj;
39371 fail:
39372 return NULL;
39373 }
39374
39375
39376 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39377 PyObject *resultobj = 0;
39378 wxWindow *arg1 = (wxWindow *) 0 ;
39379 wxMenu *arg2 = (wxMenu *) 0 ;
39380 int arg3 = (int) -1 ;
39381 int arg4 = (int) -1 ;
39382 bool result;
39383 void *argp1 = 0 ;
39384 int res1 = 0 ;
39385 void *argp2 = 0 ;
39386 int res2 = 0 ;
39387 int val3 ;
39388 int ecode3 = 0 ;
39389 int val4 ;
39390 int ecode4 = 0 ;
39391 PyObject * obj0 = 0 ;
39392 PyObject * obj1 = 0 ;
39393 PyObject * obj2 = 0 ;
39394 PyObject * obj3 = 0 ;
39395 char * kwnames[] = {
39396 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39397 };
39398
39399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39401 if (!SWIG_IsOK(res1)) {
39402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39403 }
39404 arg1 = reinterpret_cast< wxWindow * >(argp1);
39405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39406 if (!SWIG_IsOK(res2)) {
39407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39408 }
39409 arg2 = reinterpret_cast< wxMenu * >(argp2);
39410 if (obj2) {
39411 ecode3 = SWIG_AsVal_int(obj2, &val3);
39412 if (!SWIG_IsOK(ecode3)) {
39413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39414 }
39415 arg3 = static_cast< int >(val3);
39416 }
39417 if (obj3) {
39418 ecode4 = SWIG_AsVal_int(obj3, &val4);
39419 if (!SWIG_IsOK(ecode4)) {
39420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39421 }
39422 arg4 = static_cast< int >(val4);
39423 }
39424 {
39425 PyThreadState* __tstate = wxPyBeginAllowThreads();
39426 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39427 wxPyEndAllowThreads(__tstate);
39428 if (PyErr_Occurred()) SWIG_fail;
39429 }
39430 {
39431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39432 }
39433 return resultobj;
39434 fail:
39435 return NULL;
39436 }
39437
39438
39439 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39440 PyObject *resultobj = 0;
39441 wxWindow *arg1 = (wxWindow *) 0 ;
39442 wxMenu *arg2 = (wxMenu *) 0 ;
39443 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39444 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39445 bool result;
39446 void *argp1 = 0 ;
39447 int res1 = 0 ;
39448 void *argp2 = 0 ;
39449 int res2 = 0 ;
39450 wxPoint temp3 ;
39451 PyObject * obj0 = 0 ;
39452 PyObject * obj1 = 0 ;
39453 PyObject * obj2 = 0 ;
39454 char * kwnames[] = {
39455 (char *) "self",(char *) "menu",(char *) "pos", NULL
39456 };
39457
39458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39460 if (!SWIG_IsOK(res1)) {
39461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39462 }
39463 arg1 = reinterpret_cast< wxWindow * >(argp1);
39464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39465 if (!SWIG_IsOK(res2)) {
39466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39467 }
39468 arg2 = reinterpret_cast< wxMenu * >(argp2);
39469 if (obj2) {
39470 {
39471 arg3 = &temp3;
39472 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39473 }
39474 }
39475 {
39476 PyThreadState* __tstate = wxPyBeginAllowThreads();
39477 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39478 wxPyEndAllowThreads(__tstate);
39479 if (PyErr_Occurred()) SWIG_fail;
39480 }
39481 {
39482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39483 }
39484 return resultobj;
39485 fail:
39486 return NULL;
39487 }
39488
39489
39490 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39491 PyObject *resultobj = 0;
39492 wxWindow *arg1 = (wxWindow *) 0 ;
39493 bool result;
39494 void *argp1 = 0 ;
39495 int res1 = 0 ;
39496 PyObject *swig_obj[1] ;
39497
39498 if (!args) SWIG_fail;
39499 swig_obj[0] = args;
39500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39501 if (!SWIG_IsOK(res1)) {
39502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39503 }
39504 arg1 = reinterpret_cast< wxWindow * >(argp1);
39505 {
39506 PyThreadState* __tstate = wxPyBeginAllowThreads();
39507 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39508 wxPyEndAllowThreads(__tstate);
39509 if (PyErr_Occurred()) SWIG_fail;
39510 }
39511 {
39512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39513 }
39514 return resultobj;
39515 fail:
39516 return NULL;
39517 }
39518
39519
39520 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39521 PyObject *resultobj = 0;
39522 wxWindow *arg1 = (wxWindow *) 0 ;
39523 long result;
39524 void *argp1 = 0 ;
39525 int res1 = 0 ;
39526 PyObject *swig_obj[1] ;
39527
39528 if (!args) SWIG_fail;
39529 swig_obj[0] = args;
39530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39531 if (!SWIG_IsOK(res1)) {
39532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39533 }
39534 arg1 = reinterpret_cast< wxWindow * >(argp1);
39535 {
39536 PyThreadState* __tstate = wxPyBeginAllowThreads();
39537 result = (long)wxWindow_GetHandle(arg1);
39538 wxPyEndAllowThreads(__tstate);
39539 if (PyErr_Occurred()) SWIG_fail;
39540 }
39541 resultobj = SWIG_From_long(static_cast< long >(result));
39542 return resultobj;
39543 fail:
39544 return NULL;
39545 }
39546
39547
39548 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39549 PyObject *resultobj = 0;
39550 wxWindow *arg1 = (wxWindow *) 0 ;
39551 long arg2 ;
39552 void *argp1 = 0 ;
39553 int res1 = 0 ;
39554 long val2 ;
39555 int ecode2 = 0 ;
39556 PyObject * obj0 = 0 ;
39557 PyObject * obj1 = 0 ;
39558 char * kwnames[] = {
39559 (char *) "self",(char *) "handle", NULL
39560 };
39561
39562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39564 if (!SWIG_IsOK(res1)) {
39565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39566 }
39567 arg1 = reinterpret_cast< wxWindow * >(argp1);
39568 ecode2 = SWIG_AsVal_long(obj1, &val2);
39569 if (!SWIG_IsOK(ecode2)) {
39570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39571 }
39572 arg2 = static_cast< long >(val2);
39573 {
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 wxWindow_AssociateHandle(arg1,arg2);
39576 wxPyEndAllowThreads(__tstate);
39577 if (PyErr_Occurred()) SWIG_fail;
39578 }
39579 resultobj = SWIG_Py_Void();
39580 return resultobj;
39581 fail:
39582 return NULL;
39583 }
39584
39585
39586 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39587 PyObject *resultobj = 0;
39588 wxWindow *arg1 = (wxWindow *) 0 ;
39589 void *argp1 = 0 ;
39590 int res1 = 0 ;
39591 PyObject *swig_obj[1] ;
39592
39593 if (!args) SWIG_fail;
39594 swig_obj[0] = args;
39595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39596 if (!SWIG_IsOK(res1)) {
39597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39598 }
39599 arg1 = reinterpret_cast< wxWindow * >(argp1);
39600 {
39601 PyThreadState* __tstate = wxPyBeginAllowThreads();
39602 (arg1)->DissociateHandle();
39603 wxPyEndAllowThreads(__tstate);
39604 if (PyErr_Occurred()) SWIG_fail;
39605 }
39606 resultobj = SWIG_Py_Void();
39607 return resultobj;
39608 fail:
39609 return NULL;
39610 }
39611
39612
39613 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39614 PyObject *resultobj = 0;
39615 wxWindow *arg1 = (wxWindow *) 0 ;
39616 wxPaintEvent *arg2 = 0 ;
39617 void *argp1 = 0 ;
39618 int res1 = 0 ;
39619 void *argp2 = 0 ;
39620 int res2 = 0 ;
39621 PyObject * obj0 = 0 ;
39622 PyObject * obj1 = 0 ;
39623 char * kwnames[] = {
39624 (char *) "self",(char *) "event", NULL
39625 };
39626
39627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39629 if (!SWIG_IsOK(res1)) {
39630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39631 }
39632 arg1 = reinterpret_cast< wxWindow * >(argp1);
39633 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39634 if (!SWIG_IsOK(res2)) {
39635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39636 }
39637 if (!argp2) {
39638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39639 }
39640 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39641 {
39642 PyThreadState* __tstate = wxPyBeginAllowThreads();
39643 (arg1)->OnPaint(*arg2);
39644 wxPyEndAllowThreads(__tstate);
39645 if (PyErr_Occurred()) SWIG_fail;
39646 }
39647 resultobj = SWIG_Py_Void();
39648 return resultobj;
39649 fail:
39650 return NULL;
39651 }
39652
39653
39654 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39655 PyObject *resultobj = 0;
39656 wxWindow *arg1 = (wxWindow *) 0 ;
39657 int arg2 ;
39658 bool result;
39659 void *argp1 = 0 ;
39660 int res1 = 0 ;
39661 int val2 ;
39662 int ecode2 = 0 ;
39663 PyObject * obj0 = 0 ;
39664 PyObject * obj1 = 0 ;
39665 char * kwnames[] = {
39666 (char *) "self",(char *) "orient", NULL
39667 };
39668
39669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39671 if (!SWIG_IsOK(res1)) {
39672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39673 }
39674 arg1 = reinterpret_cast< wxWindow * >(argp1);
39675 ecode2 = SWIG_AsVal_int(obj1, &val2);
39676 if (!SWIG_IsOK(ecode2)) {
39677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39678 }
39679 arg2 = static_cast< int >(val2);
39680 {
39681 PyThreadState* __tstate = wxPyBeginAllowThreads();
39682 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39683 wxPyEndAllowThreads(__tstate);
39684 if (PyErr_Occurred()) SWIG_fail;
39685 }
39686 {
39687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39688 }
39689 return resultobj;
39690 fail:
39691 return NULL;
39692 }
39693
39694
39695 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39696 PyObject *resultobj = 0;
39697 wxWindow *arg1 = (wxWindow *) 0 ;
39698 int arg2 ;
39699 int arg3 ;
39700 int arg4 ;
39701 int arg5 ;
39702 bool arg6 = (bool) true ;
39703 void *argp1 = 0 ;
39704 int res1 = 0 ;
39705 int val2 ;
39706 int ecode2 = 0 ;
39707 int val3 ;
39708 int ecode3 = 0 ;
39709 int val4 ;
39710 int ecode4 = 0 ;
39711 int val5 ;
39712 int ecode5 = 0 ;
39713 bool val6 ;
39714 int ecode6 = 0 ;
39715 PyObject * obj0 = 0 ;
39716 PyObject * obj1 = 0 ;
39717 PyObject * obj2 = 0 ;
39718 PyObject * obj3 = 0 ;
39719 PyObject * obj4 = 0 ;
39720 PyObject * obj5 = 0 ;
39721 char * kwnames[] = {
39722 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39723 };
39724
39725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39727 if (!SWIG_IsOK(res1)) {
39728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39729 }
39730 arg1 = reinterpret_cast< wxWindow * >(argp1);
39731 ecode2 = SWIG_AsVal_int(obj1, &val2);
39732 if (!SWIG_IsOK(ecode2)) {
39733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39734 }
39735 arg2 = static_cast< int >(val2);
39736 ecode3 = SWIG_AsVal_int(obj2, &val3);
39737 if (!SWIG_IsOK(ecode3)) {
39738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39739 }
39740 arg3 = static_cast< int >(val3);
39741 ecode4 = SWIG_AsVal_int(obj3, &val4);
39742 if (!SWIG_IsOK(ecode4)) {
39743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39744 }
39745 arg4 = static_cast< int >(val4);
39746 ecode5 = SWIG_AsVal_int(obj4, &val5);
39747 if (!SWIG_IsOK(ecode5)) {
39748 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39749 }
39750 arg5 = static_cast< int >(val5);
39751 if (obj5) {
39752 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39753 if (!SWIG_IsOK(ecode6)) {
39754 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39755 }
39756 arg6 = static_cast< bool >(val6);
39757 }
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39761 wxPyEndAllowThreads(__tstate);
39762 if (PyErr_Occurred()) SWIG_fail;
39763 }
39764 resultobj = SWIG_Py_Void();
39765 return resultobj;
39766 fail:
39767 return NULL;
39768 }
39769
39770
39771 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39772 PyObject *resultobj = 0;
39773 wxWindow *arg1 = (wxWindow *) 0 ;
39774 int arg2 ;
39775 int arg3 ;
39776 bool arg4 = (bool) true ;
39777 void *argp1 = 0 ;
39778 int res1 = 0 ;
39779 int val2 ;
39780 int ecode2 = 0 ;
39781 int val3 ;
39782 int ecode3 = 0 ;
39783 bool val4 ;
39784 int ecode4 = 0 ;
39785 PyObject * obj0 = 0 ;
39786 PyObject * obj1 = 0 ;
39787 PyObject * obj2 = 0 ;
39788 PyObject * obj3 = 0 ;
39789 char * kwnames[] = {
39790 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39791 };
39792
39793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39795 if (!SWIG_IsOK(res1)) {
39796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39797 }
39798 arg1 = reinterpret_cast< wxWindow * >(argp1);
39799 ecode2 = SWIG_AsVal_int(obj1, &val2);
39800 if (!SWIG_IsOK(ecode2)) {
39801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39802 }
39803 arg2 = static_cast< int >(val2);
39804 ecode3 = SWIG_AsVal_int(obj2, &val3);
39805 if (!SWIG_IsOK(ecode3)) {
39806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39807 }
39808 arg3 = static_cast< int >(val3);
39809 if (obj3) {
39810 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39811 if (!SWIG_IsOK(ecode4)) {
39812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39813 }
39814 arg4 = static_cast< bool >(val4);
39815 }
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 (arg1)->SetScrollPos(arg2,arg3,arg4);
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 resultobj = SWIG_Py_Void();
39823 return resultobj;
39824 fail:
39825 return NULL;
39826 }
39827
39828
39829 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39830 PyObject *resultobj = 0;
39831 wxWindow *arg1 = (wxWindow *) 0 ;
39832 int arg2 ;
39833 int result;
39834 void *argp1 = 0 ;
39835 int res1 = 0 ;
39836 int val2 ;
39837 int ecode2 = 0 ;
39838 PyObject * obj0 = 0 ;
39839 PyObject * obj1 = 0 ;
39840 char * kwnames[] = {
39841 (char *) "self",(char *) "orientation", NULL
39842 };
39843
39844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39846 if (!SWIG_IsOK(res1)) {
39847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39848 }
39849 arg1 = reinterpret_cast< wxWindow * >(argp1);
39850 ecode2 = SWIG_AsVal_int(obj1, &val2);
39851 if (!SWIG_IsOK(ecode2)) {
39852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39853 }
39854 arg2 = static_cast< int >(val2);
39855 {
39856 PyThreadState* __tstate = wxPyBeginAllowThreads();
39857 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39858 wxPyEndAllowThreads(__tstate);
39859 if (PyErr_Occurred()) SWIG_fail;
39860 }
39861 resultobj = SWIG_From_int(static_cast< int >(result));
39862 return resultobj;
39863 fail:
39864 return NULL;
39865 }
39866
39867
39868 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39869 PyObject *resultobj = 0;
39870 wxWindow *arg1 = (wxWindow *) 0 ;
39871 int arg2 ;
39872 int result;
39873 void *argp1 = 0 ;
39874 int res1 = 0 ;
39875 int val2 ;
39876 int ecode2 = 0 ;
39877 PyObject * obj0 = 0 ;
39878 PyObject * obj1 = 0 ;
39879 char * kwnames[] = {
39880 (char *) "self",(char *) "orientation", NULL
39881 };
39882
39883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39885 if (!SWIG_IsOK(res1)) {
39886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39887 }
39888 arg1 = reinterpret_cast< wxWindow * >(argp1);
39889 ecode2 = SWIG_AsVal_int(obj1, &val2);
39890 if (!SWIG_IsOK(ecode2)) {
39891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39892 }
39893 arg2 = static_cast< int >(val2);
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 resultobj = SWIG_From_int(static_cast< int >(result));
39901 return resultobj;
39902 fail:
39903 return NULL;
39904 }
39905
39906
39907 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39908 PyObject *resultobj = 0;
39909 wxWindow *arg1 = (wxWindow *) 0 ;
39910 int arg2 ;
39911 int result;
39912 void *argp1 = 0 ;
39913 int res1 = 0 ;
39914 int val2 ;
39915 int ecode2 = 0 ;
39916 PyObject * obj0 = 0 ;
39917 PyObject * obj1 = 0 ;
39918 char * kwnames[] = {
39919 (char *) "self",(char *) "orientation", NULL
39920 };
39921
39922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39924 if (!SWIG_IsOK(res1)) {
39925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39926 }
39927 arg1 = reinterpret_cast< wxWindow * >(argp1);
39928 ecode2 = SWIG_AsVal_int(obj1, &val2);
39929 if (!SWIG_IsOK(ecode2)) {
39930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39931 }
39932 arg2 = static_cast< int >(val2);
39933 {
39934 PyThreadState* __tstate = wxPyBeginAllowThreads();
39935 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39936 wxPyEndAllowThreads(__tstate);
39937 if (PyErr_Occurred()) SWIG_fail;
39938 }
39939 resultobj = SWIG_From_int(static_cast< int >(result));
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj = 0;
39948 wxWindow *arg1 = (wxWindow *) 0 ;
39949 int arg2 ;
39950 int arg3 ;
39951 wxRect *arg4 = (wxRect *) NULL ;
39952 void *argp1 = 0 ;
39953 int res1 = 0 ;
39954 int val2 ;
39955 int ecode2 = 0 ;
39956 int val3 ;
39957 int ecode3 = 0 ;
39958 void *argp4 = 0 ;
39959 int res4 = 0 ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 PyObject * obj2 = 0 ;
39963 PyObject * obj3 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39972 }
39973 arg1 = reinterpret_cast< wxWindow * >(argp1);
39974 ecode2 = SWIG_AsVal_int(obj1, &val2);
39975 if (!SWIG_IsOK(ecode2)) {
39976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39977 }
39978 arg2 = static_cast< int >(val2);
39979 ecode3 = SWIG_AsVal_int(obj2, &val3);
39980 if (!SWIG_IsOK(ecode3)) {
39981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39982 }
39983 arg3 = static_cast< int >(val3);
39984 if (obj3) {
39985 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39986 if (!SWIG_IsOK(res4)) {
39987 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39988 }
39989 arg4 = reinterpret_cast< wxRect * >(argp4);
39990 }
39991 {
39992 PyThreadState* __tstate = wxPyBeginAllowThreads();
39993 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39994 wxPyEndAllowThreads(__tstate);
39995 if (PyErr_Occurred()) SWIG_fail;
39996 }
39997 resultobj = SWIG_Py_Void();
39998 return resultobj;
39999 fail:
40000 return NULL;
40001 }
40002
40003
40004 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40005 PyObject *resultobj = 0;
40006 wxWindow *arg1 = (wxWindow *) 0 ;
40007 int arg2 ;
40008 bool result;
40009 void *argp1 = 0 ;
40010 int res1 = 0 ;
40011 int val2 ;
40012 int ecode2 = 0 ;
40013 PyObject * obj0 = 0 ;
40014 PyObject * obj1 = 0 ;
40015 char * kwnames[] = {
40016 (char *) "self",(char *) "lines", NULL
40017 };
40018
40019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40021 if (!SWIG_IsOK(res1)) {
40022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40023 }
40024 arg1 = reinterpret_cast< wxWindow * >(argp1);
40025 ecode2 = SWIG_AsVal_int(obj1, &val2);
40026 if (!SWIG_IsOK(ecode2)) {
40027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40028 }
40029 arg2 = static_cast< int >(val2);
40030 {
40031 PyThreadState* __tstate = wxPyBeginAllowThreads();
40032 result = (bool)(arg1)->ScrollLines(arg2);
40033 wxPyEndAllowThreads(__tstate);
40034 if (PyErr_Occurred()) SWIG_fail;
40035 }
40036 {
40037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40038 }
40039 return resultobj;
40040 fail:
40041 return NULL;
40042 }
40043
40044
40045 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40046 PyObject *resultobj = 0;
40047 wxWindow *arg1 = (wxWindow *) 0 ;
40048 int arg2 ;
40049 bool result;
40050 void *argp1 = 0 ;
40051 int res1 = 0 ;
40052 int val2 ;
40053 int ecode2 = 0 ;
40054 PyObject * obj0 = 0 ;
40055 PyObject * obj1 = 0 ;
40056 char * kwnames[] = {
40057 (char *) "self",(char *) "pages", NULL
40058 };
40059
40060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40062 if (!SWIG_IsOK(res1)) {
40063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40064 }
40065 arg1 = reinterpret_cast< wxWindow * >(argp1);
40066 ecode2 = SWIG_AsVal_int(obj1, &val2);
40067 if (!SWIG_IsOK(ecode2)) {
40068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40069 }
40070 arg2 = static_cast< int >(val2);
40071 {
40072 PyThreadState* __tstate = wxPyBeginAllowThreads();
40073 result = (bool)(arg1)->ScrollPages(arg2);
40074 wxPyEndAllowThreads(__tstate);
40075 if (PyErr_Occurred()) SWIG_fail;
40076 }
40077 {
40078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40079 }
40080 return resultobj;
40081 fail:
40082 return NULL;
40083 }
40084
40085
40086 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40087 PyObject *resultobj = 0;
40088 wxWindow *arg1 = (wxWindow *) 0 ;
40089 bool result;
40090 void *argp1 = 0 ;
40091 int res1 = 0 ;
40092 PyObject *swig_obj[1] ;
40093
40094 if (!args) SWIG_fail;
40095 swig_obj[0] = args;
40096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40097 if (!SWIG_IsOK(res1)) {
40098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40099 }
40100 arg1 = reinterpret_cast< wxWindow * >(argp1);
40101 {
40102 PyThreadState* __tstate = wxPyBeginAllowThreads();
40103 result = (bool)(arg1)->LineUp();
40104 wxPyEndAllowThreads(__tstate);
40105 if (PyErr_Occurred()) SWIG_fail;
40106 }
40107 {
40108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40109 }
40110 return resultobj;
40111 fail:
40112 return NULL;
40113 }
40114
40115
40116 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40117 PyObject *resultobj = 0;
40118 wxWindow *arg1 = (wxWindow *) 0 ;
40119 bool result;
40120 void *argp1 = 0 ;
40121 int res1 = 0 ;
40122 PyObject *swig_obj[1] ;
40123
40124 if (!args) SWIG_fail;
40125 swig_obj[0] = args;
40126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40127 if (!SWIG_IsOK(res1)) {
40128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40129 }
40130 arg1 = reinterpret_cast< wxWindow * >(argp1);
40131 {
40132 PyThreadState* __tstate = wxPyBeginAllowThreads();
40133 result = (bool)(arg1)->LineDown();
40134 wxPyEndAllowThreads(__tstate);
40135 if (PyErr_Occurred()) SWIG_fail;
40136 }
40137 {
40138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40139 }
40140 return resultobj;
40141 fail:
40142 return NULL;
40143 }
40144
40145
40146 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40147 PyObject *resultobj = 0;
40148 wxWindow *arg1 = (wxWindow *) 0 ;
40149 bool result;
40150 void *argp1 = 0 ;
40151 int res1 = 0 ;
40152 PyObject *swig_obj[1] ;
40153
40154 if (!args) SWIG_fail;
40155 swig_obj[0] = args;
40156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40157 if (!SWIG_IsOK(res1)) {
40158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40159 }
40160 arg1 = reinterpret_cast< wxWindow * >(argp1);
40161 {
40162 PyThreadState* __tstate = wxPyBeginAllowThreads();
40163 result = (bool)(arg1)->PageUp();
40164 wxPyEndAllowThreads(__tstate);
40165 if (PyErr_Occurred()) SWIG_fail;
40166 }
40167 {
40168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40169 }
40170 return resultobj;
40171 fail:
40172 return NULL;
40173 }
40174
40175
40176 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40177 PyObject *resultobj = 0;
40178 wxWindow *arg1 = (wxWindow *) 0 ;
40179 bool result;
40180 void *argp1 = 0 ;
40181 int res1 = 0 ;
40182 PyObject *swig_obj[1] ;
40183
40184 if (!args) SWIG_fail;
40185 swig_obj[0] = args;
40186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40187 if (!SWIG_IsOK(res1)) {
40188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40189 }
40190 arg1 = reinterpret_cast< wxWindow * >(argp1);
40191 {
40192 PyThreadState* __tstate = wxPyBeginAllowThreads();
40193 result = (bool)(arg1)->PageDown();
40194 wxPyEndAllowThreads(__tstate);
40195 if (PyErr_Occurred()) SWIG_fail;
40196 }
40197 {
40198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40199 }
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40207 PyObject *resultobj = 0;
40208 wxWindow *arg1 = (wxWindow *) 0 ;
40209 wxString *arg2 = 0 ;
40210 void *argp1 = 0 ;
40211 int res1 = 0 ;
40212 bool temp2 = false ;
40213 PyObject * obj0 = 0 ;
40214 PyObject * obj1 = 0 ;
40215 char * kwnames[] = {
40216 (char *) "self",(char *) "text", NULL
40217 };
40218
40219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40221 if (!SWIG_IsOK(res1)) {
40222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40223 }
40224 arg1 = reinterpret_cast< wxWindow * >(argp1);
40225 {
40226 arg2 = wxString_in_helper(obj1);
40227 if (arg2 == NULL) SWIG_fail;
40228 temp2 = true;
40229 }
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 (arg1)->SetHelpText((wxString const &)*arg2);
40233 wxPyEndAllowThreads(__tstate);
40234 if (PyErr_Occurred()) SWIG_fail;
40235 }
40236 resultobj = SWIG_Py_Void();
40237 {
40238 if (temp2)
40239 delete arg2;
40240 }
40241 return resultobj;
40242 fail:
40243 {
40244 if (temp2)
40245 delete arg2;
40246 }
40247 return NULL;
40248 }
40249
40250
40251 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40252 PyObject *resultobj = 0;
40253 wxWindow *arg1 = (wxWindow *) 0 ;
40254 wxString *arg2 = 0 ;
40255 void *argp1 = 0 ;
40256 int res1 = 0 ;
40257 bool temp2 = false ;
40258 PyObject * obj0 = 0 ;
40259 PyObject * obj1 = 0 ;
40260 char * kwnames[] = {
40261 (char *) "self",(char *) "text", NULL
40262 };
40263
40264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40266 if (!SWIG_IsOK(res1)) {
40267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40268 }
40269 arg1 = reinterpret_cast< wxWindow * >(argp1);
40270 {
40271 arg2 = wxString_in_helper(obj1);
40272 if (arg2 == NULL) SWIG_fail;
40273 temp2 = true;
40274 }
40275 {
40276 PyThreadState* __tstate = wxPyBeginAllowThreads();
40277 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40278 wxPyEndAllowThreads(__tstate);
40279 if (PyErr_Occurred()) SWIG_fail;
40280 }
40281 resultobj = SWIG_Py_Void();
40282 {
40283 if (temp2)
40284 delete arg2;
40285 }
40286 return resultobj;
40287 fail:
40288 {
40289 if (temp2)
40290 delete arg2;
40291 }
40292 return NULL;
40293 }
40294
40295
40296 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40297 PyObject *resultobj = 0;
40298 wxWindow *arg1 = (wxWindow *) 0 ;
40299 wxPoint *arg2 = 0 ;
40300 wxHelpEvent::Origin arg3 ;
40301 wxString result;
40302 void *argp1 = 0 ;
40303 int res1 = 0 ;
40304 wxPoint temp2 ;
40305 void *argp3 ;
40306 int res3 = 0 ;
40307 PyObject * obj0 = 0 ;
40308 PyObject * obj1 = 0 ;
40309 PyObject * obj2 = 0 ;
40310 char * kwnames[] = {
40311 (char *) "self",(char *) "pt",(char *) "origin", NULL
40312 };
40313
40314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40316 if (!SWIG_IsOK(res1)) {
40317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40318 }
40319 arg1 = reinterpret_cast< wxWindow * >(argp1);
40320 {
40321 arg2 = &temp2;
40322 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40323 }
40324 {
40325 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40326 if (!SWIG_IsOK(res3)) {
40327 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40328 }
40329 if (!argp3) {
40330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40331 } else {
40332 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40333 arg3 = *temp;
40334 if (SWIG_IsNewObj(res3)) delete temp;
40335 }
40336 }
40337 {
40338 PyThreadState* __tstate = wxPyBeginAllowThreads();
40339 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40340 wxPyEndAllowThreads(__tstate);
40341 if (PyErr_Occurred()) SWIG_fail;
40342 }
40343 {
40344 #if wxUSE_UNICODE
40345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40346 #else
40347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40348 #endif
40349 }
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40357 PyObject *resultobj = 0;
40358 wxWindow *arg1 = (wxWindow *) 0 ;
40359 wxString result;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 PyObject *swig_obj[1] ;
40363
40364 if (!args) SWIG_fail;
40365 swig_obj[0] = args;
40366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40367 if (!SWIG_IsOK(res1)) {
40368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40369 }
40370 arg1 = reinterpret_cast< wxWindow * >(argp1);
40371 {
40372 PyThreadState* __tstate = wxPyBeginAllowThreads();
40373 result = ((wxWindow const *)arg1)->GetHelpText();
40374 wxPyEndAllowThreads(__tstate);
40375 if (PyErr_Occurred()) SWIG_fail;
40376 }
40377 {
40378 #if wxUSE_UNICODE
40379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40380 #else
40381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40382 #endif
40383 }
40384 return resultobj;
40385 fail:
40386 return NULL;
40387 }
40388
40389
40390 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40391 PyObject *resultobj = 0;
40392 wxWindow *arg1 = (wxWindow *) 0 ;
40393 wxString *arg2 = 0 ;
40394 void *argp1 = 0 ;
40395 int res1 = 0 ;
40396 bool temp2 = false ;
40397 PyObject * obj0 = 0 ;
40398 PyObject * obj1 = 0 ;
40399 char * kwnames[] = {
40400 (char *) "self",(char *) "tip", NULL
40401 };
40402
40403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40405 if (!SWIG_IsOK(res1)) {
40406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40407 }
40408 arg1 = reinterpret_cast< wxWindow * >(argp1);
40409 {
40410 arg2 = wxString_in_helper(obj1);
40411 if (arg2 == NULL) SWIG_fail;
40412 temp2 = true;
40413 }
40414 {
40415 PyThreadState* __tstate = wxPyBeginAllowThreads();
40416 (arg1)->SetToolTip((wxString const &)*arg2);
40417 wxPyEndAllowThreads(__tstate);
40418 if (PyErr_Occurred()) SWIG_fail;
40419 }
40420 resultobj = SWIG_Py_Void();
40421 {
40422 if (temp2)
40423 delete arg2;
40424 }
40425 return resultobj;
40426 fail:
40427 {
40428 if (temp2)
40429 delete arg2;
40430 }
40431 return NULL;
40432 }
40433
40434
40435 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40436 PyObject *resultobj = 0;
40437 wxWindow *arg1 = (wxWindow *) 0 ;
40438 wxToolTip *arg2 = (wxToolTip *) 0 ;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 int res2 = 0 ;
40442 PyObject * obj0 = 0 ;
40443 PyObject * obj1 = 0 ;
40444 char * kwnames[] = {
40445 (char *) "self",(char *) "tip", NULL
40446 };
40447
40448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40450 if (!SWIG_IsOK(res1)) {
40451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40452 }
40453 arg1 = reinterpret_cast< wxWindow * >(argp1);
40454 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40455 if (!SWIG_IsOK(res2)) {
40456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40457 }
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 (arg1)->SetToolTip(arg2);
40461 wxPyEndAllowThreads(__tstate);
40462 if (PyErr_Occurred()) SWIG_fail;
40463 }
40464 resultobj = SWIG_Py_Void();
40465 return resultobj;
40466 fail:
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40472 PyObject *resultobj = 0;
40473 wxWindow *arg1 = (wxWindow *) 0 ;
40474 wxToolTip *result = 0 ;
40475 void *argp1 = 0 ;
40476 int res1 = 0 ;
40477 PyObject *swig_obj[1] ;
40478
40479 if (!args) SWIG_fail;
40480 swig_obj[0] = args;
40481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40482 if (!SWIG_IsOK(res1)) {
40483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40484 }
40485 arg1 = reinterpret_cast< wxWindow * >(argp1);
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 {
40493 resultobj = wxPyMake_wxObject(result, (bool)0);
40494 }
40495 return resultobj;
40496 fail:
40497 return NULL;
40498 }
40499
40500
40501 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40502 PyObject *resultobj = 0;
40503 wxWindow *arg1 = (wxWindow *) 0 ;
40504 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40505 void *argp1 = 0 ;
40506 int res1 = 0 ;
40507 int res2 = 0 ;
40508 PyObject * obj0 = 0 ;
40509 PyObject * obj1 = 0 ;
40510 char * kwnames[] = {
40511 (char *) "self",(char *) "dropTarget", NULL
40512 };
40513
40514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40516 if (!SWIG_IsOK(res1)) {
40517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40518 }
40519 arg1 = reinterpret_cast< wxWindow * >(argp1);
40520 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40521 if (!SWIG_IsOK(res2)) {
40522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40523 }
40524 {
40525 PyThreadState* __tstate = wxPyBeginAllowThreads();
40526 (arg1)->SetDropTarget(arg2);
40527 wxPyEndAllowThreads(__tstate);
40528 if (PyErr_Occurred()) SWIG_fail;
40529 }
40530 resultobj = SWIG_Py_Void();
40531 return resultobj;
40532 fail:
40533 return NULL;
40534 }
40535
40536
40537 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40538 PyObject *resultobj = 0;
40539 wxWindow *arg1 = (wxWindow *) 0 ;
40540 wxPyDropTarget *result = 0 ;
40541 void *argp1 = 0 ;
40542 int res1 = 0 ;
40543 PyObject *swig_obj[1] ;
40544
40545 if (!args) SWIG_fail;
40546 swig_obj[0] = args;
40547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40548 if (!SWIG_IsOK(res1)) {
40549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40550 }
40551 arg1 = reinterpret_cast< wxWindow * >(argp1);
40552 {
40553 PyThreadState* __tstate = wxPyBeginAllowThreads();
40554 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40555 wxPyEndAllowThreads(__tstate);
40556 if (PyErr_Occurred()) SWIG_fail;
40557 }
40558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj = 0;
40567 wxWindow *arg1 = (wxWindow *) 0 ;
40568 bool arg2 ;
40569 void *argp1 = 0 ;
40570 int res1 = 0 ;
40571 bool val2 ;
40572 int ecode2 = 0 ;
40573 PyObject * obj0 = 0 ;
40574 PyObject * obj1 = 0 ;
40575 char * kwnames[] = {
40576 (char *) "self",(char *) "accept", NULL
40577 };
40578
40579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40581 if (!SWIG_IsOK(res1)) {
40582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40583 }
40584 arg1 = reinterpret_cast< wxWindow * >(argp1);
40585 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40586 if (!SWIG_IsOK(ecode2)) {
40587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40588 }
40589 arg2 = static_cast< bool >(val2);
40590 {
40591 PyThreadState* __tstate = wxPyBeginAllowThreads();
40592 (arg1)->DragAcceptFiles(arg2);
40593 wxPyEndAllowThreads(__tstate);
40594 if (PyErr_Occurred()) SWIG_fail;
40595 }
40596 resultobj = SWIG_Py_Void();
40597 return resultobj;
40598 fail:
40599 return NULL;
40600 }
40601
40602
40603 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40604 PyObject *resultobj = 0;
40605 wxWindow *arg1 = (wxWindow *) 0 ;
40606 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 int res2 = 0 ;
40610 PyObject * obj0 = 0 ;
40611 PyObject * obj1 = 0 ;
40612 char * kwnames[] = {
40613 (char *) "self",(char *) "constraints", NULL
40614 };
40615
40616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40618 if (!SWIG_IsOK(res1)) {
40619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40620 }
40621 arg1 = reinterpret_cast< wxWindow * >(argp1);
40622 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40623 if (!SWIG_IsOK(res2)) {
40624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40625 }
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->SetConstraints(arg2);
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 resultobj = SWIG_Py_Void();
40633 return resultobj;
40634 fail:
40635 return NULL;
40636 }
40637
40638
40639 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40640 PyObject *resultobj = 0;
40641 wxWindow *arg1 = (wxWindow *) 0 ;
40642 wxLayoutConstraints *result = 0 ;
40643 void *argp1 = 0 ;
40644 int res1 = 0 ;
40645 PyObject *swig_obj[1] ;
40646
40647 if (!args) SWIG_fail;
40648 swig_obj[0] = args;
40649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40650 if (!SWIG_IsOK(res1)) {
40651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40652 }
40653 arg1 = reinterpret_cast< wxWindow * >(argp1);
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40661 return resultobj;
40662 fail:
40663 return NULL;
40664 }
40665
40666
40667 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40668 PyObject *resultobj = 0;
40669 wxWindow *arg1 = (wxWindow *) 0 ;
40670 bool arg2 ;
40671 void *argp1 = 0 ;
40672 int res1 = 0 ;
40673 bool val2 ;
40674 int ecode2 = 0 ;
40675 PyObject * obj0 = 0 ;
40676 PyObject * obj1 = 0 ;
40677 char * kwnames[] = {
40678 (char *) "self",(char *) "autoLayout", NULL
40679 };
40680
40681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40683 if (!SWIG_IsOK(res1)) {
40684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40685 }
40686 arg1 = reinterpret_cast< wxWindow * >(argp1);
40687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40688 if (!SWIG_IsOK(ecode2)) {
40689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40690 }
40691 arg2 = static_cast< bool >(val2);
40692 {
40693 PyThreadState* __tstate = wxPyBeginAllowThreads();
40694 (arg1)->SetAutoLayout(arg2);
40695 wxPyEndAllowThreads(__tstate);
40696 if (PyErr_Occurred()) SWIG_fail;
40697 }
40698 resultobj = SWIG_Py_Void();
40699 return resultobj;
40700 fail:
40701 return NULL;
40702 }
40703
40704
40705 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40706 PyObject *resultobj = 0;
40707 wxWindow *arg1 = (wxWindow *) 0 ;
40708 bool result;
40709 void *argp1 = 0 ;
40710 int res1 = 0 ;
40711 PyObject *swig_obj[1] ;
40712
40713 if (!args) SWIG_fail;
40714 swig_obj[0] = args;
40715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40716 if (!SWIG_IsOK(res1)) {
40717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40718 }
40719 arg1 = reinterpret_cast< wxWindow * >(argp1);
40720 {
40721 PyThreadState* __tstate = wxPyBeginAllowThreads();
40722 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40723 wxPyEndAllowThreads(__tstate);
40724 if (PyErr_Occurred()) SWIG_fail;
40725 }
40726 {
40727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40728 }
40729 return resultobj;
40730 fail:
40731 return NULL;
40732 }
40733
40734
40735 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40736 PyObject *resultobj = 0;
40737 wxWindow *arg1 = (wxWindow *) 0 ;
40738 bool result;
40739 void *argp1 = 0 ;
40740 int res1 = 0 ;
40741 PyObject *swig_obj[1] ;
40742
40743 if (!args) SWIG_fail;
40744 swig_obj[0] = args;
40745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40746 if (!SWIG_IsOK(res1)) {
40747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40748 }
40749 arg1 = reinterpret_cast< wxWindow * >(argp1);
40750 {
40751 PyThreadState* __tstate = wxPyBeginAllowThreads();
40752 result = (bool)(arg1)->Layout();
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 {
40757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40758 }
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40766 PyObject *resultobj = 0;
40767 wxWindow *arg1 = (wxWindow *) 0 ;
40768 wxSizer *arg2 = (wxSizer *) 0 ;
40769 bool arg3 = (bool) true ;
40770 void *argp1 = 0 ;
40771 int res1 = 0 ;
40772 int res2 = 0 ;
40773 bool val3 ;
40774 int ecode3 = 0 ;
40775 PyObject * obj0 = 0 ;
40776 PyObject * obj1 = 0 ;
40777 PyObject * obj2 = 0 ;
40778 char * kwnames[] = {
40779 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40780 };
40781
40782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40784 if (!SWIG_IsOK(res1)) {
40785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40786 }
40787 arg1 = reinterpret_cast< wxWindow * >(argp1);
40788 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40789 if (!SWIG_IsOK(res2)) {
40790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40791 }
40792 if (obj2) {
40793 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40794 if (!SWIG_IsOK(ecode3)) {
40795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40796 }
40797 arg3 = static_cast< bool >(val3);
40798 }
40799 {
40800 PyThreadState* __tstate = wxPyBeginAllowThreads();
40801 (arg1)->SetSizer(arg2,arg3);
40802 wxPyEndAllowThreads(__tstate);
40803 if (PyErr_Occurred()) SWIG_fail;
40804 }
40805 resultobj = SWIG_Py_Void();
40806 return resultobj;
40807 fail:
40808 return NULL;
40809 }
40810
40811
40812 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40813 PyObject *resultobj = 0;
40814 wxWindow *arg1 = (wxWindow *) 0 ;
40815 wxSizer *arg2 = (wxSizer *) 0 ;
40816 bool arg3 = (bool) true ;
40817 void *argp1 = 0 ;
40818 int res1 = 0 ;
40819 int res2 = 0 ;
40820 bool val3 ;
40821 int ecode3 = 0 ;
40822 PyObject * obj0 = 0 ;
40823 PyObject * obj1 = 0 ;
40824 PyObject * obj2 = 0 ;
40825 char * kwnames[] = {
40826 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40827 };
40828
40829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40831 if (!SWIG_IsOK(res1)) {
40832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40833 }
40834 arg1 = reinterpret_cast< wxWindow * >(argp1);
40835 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40836 if (!SWIG_IsOK(res2)) {
40837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40838 }
40839 if (obj2) {
40840 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40841 if (!SWIG_IsOK(ecode3)) {
40842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40843 }
40844 arg3 = static_cast< bool >(val3);
40845 }
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 (arg1)->SetSizerAndFit(arg2,arg3);
40849 wxPyEndAllowThreads(__tstate);
40850 if (PyErr_Occurred()) SWIG_fail;
40851 }
40852 resultobj = SWIG_Py_Void();
40853 return resultobj;
40854 fail:
40855 return NULL;
40856 }
40857
40858
40859 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40860 PyObject *resultobj = 0;
40861 wxWindow *arg1 = (wxWindow *) 0 ;
40862 wxSizer *result = 0 ;
40863 void *argp1 = 0 ;
40864 int res1 = 0 ;
40865 PyObject *swig_obj[1] ;
40866
40867 if (!args) SWIG_fail;
40868 swig_obj[0] = args;
40869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40870 if (!SWIG_IsOK(res1)) {
40871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40872 }
40873 arg1 = reinterpret_cast< wxWindow * >(argp1);
40874 {
40875 PyThreadState* __tstate = wxPyBeginAllowThreads();
40876 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40877 wxPyEndAllowThreads(__tstate);
40878 if (PyErr_Occurred()) SWIG_fail;
40879 }
40880 {
40881 resultobj = wxPyMake_wxObject(result, (bool)0);
40882 }
40883 return resultobj;
40884 fail:
40885 return NULL;
40886 }
40887
40888
40889 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40890 PyObject *resultobj = 0;
40891 wxWindow *arg1 = (wxWindow *) 0 ;
40892 wxSizer *arg2 = (wxSizer *) 0 ;
40893 void *argp1 = 0 ;
40894 int res1 = 0 ;
40895 void *argp2 = 0 ;
40896 int res2 = 0 ;
40897 PyObject * obj0 = 0 ;
40898 PyObject * obj1 = 0 ;
40899 char * kwnames[] = {
40900 (char *) "self",(char *) "sizer", NULL
40901 };
40902
40903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40905 if (!SWIG_IsOK(res1)) {
40906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40907 }
40908 arg1 = reinterpret_cast< wxWindow * >(argp1);
40909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40910 if (!SWIG_IsOK(res2)) {
40911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40912 }
40913 arg2 = reinterpret_cast< wxSizer * >(argp2);
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 (arg1)->SetContainingSizer(arg2);
40917 wxPyEndAllowThreads(__tstate);
40918 if (PyErr_Occurred()) SWIG_fail;
40919 }
40920 resultobj = SWIG_Py_Void();
40921 return resultobj;
40922 fail:
40923 return NULL;
40924 }
40925
40926
40927 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40928 PyObject *resultobj = 0;
40929 wxWindow *arg1 = (wxWindow *) 0 ;
40930 wxSizer *result = 0 ;
40931 void *argp1 = 0 ;
40932 int res1 = 0 ;
40933 PyObject *swig_obj[1] ;
40934
40935 if (!args) SWIG_fail;
40936 swig_obj[0] = args;
40937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40938 if (!SWIG_IsOK(res1)) {
40939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40940 }
40941 arg1 = reinterpret_cast< wxWindow * >(argp1);
40942 {
40943 PyThreadState* __tstate = wxPyBeginAllowThreads();
40944 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40945 wxPyEndAllowThreads(__tstate);
40946 if (PyErr_Occurred()) SWIG_fail;
40947 }
40948 {
40949 resultobj = wxPyMake_wxObject(result, (bool)0);
40950 }
40951 return resultobj;
40952 fail:
40953 return NULL;
40954 }
40955
40956
40957 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40958 PyObject *resultobj = 0;
40959 wxWindow *arg1 = (wxWindow *) 0 ;
40960 void *argp1 = 0 ;
40961 int res1 = 0 ;
40962 PyObject *swig_obj[1] ;
40963
40964 if (!args) SWIG_fail;
40965 swig_obj[0] = args;
40966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40967 if (!SWIG_IsOK(res1)) {
40968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40969 }
40970 arg1 = reinterpret_cast< wxWindow * >(argp1);
40971 {
40972 PyThreadState* __tstate = wxPyBeginAllowThreads();
40973 (arg1)->InheritAttributes();
40974 wxPyEndAllowThreads(__tstate);
40975 if (PyErr_Occurred()) SWIG_fail;
40976 }
40977 resultobj = SWIG_Py_Void();
40978 return resultobj;
40979 fail:
40980 return NULL;
40981 }
40982
40983
40984 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40985 PyObject *resultobj = 0;
40986 wxWindow *arg1 = (wxWindow *) 0 ;
40987 bool result;
40988 void *argp1 = 0 ;
40989 int res1 = 0 ;
40990 PyObject *swig_obj[1] ;
40991
40992 if (!args) SWIG_fail;
40993 swig_obj[0] = args;
40994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40995 if (!SWIG_IsOK(res1)) {
40996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40997 }
40998 arg1 = reinterpret_cast< wxWindow * >(argp1);
40999 {
41000 PyThreadState* __tstate = wxPyBeginAllowThreads();
41001 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 {
41006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41007 }
41008 return resultobj;
41009 fail:
41010 return NULL;
41011 }
41012
41013
41014 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41015 PyObject *resultobj = 0;
41016 wxWindow *arg1 = (wxWindow *) 0 ;
41017 bool result;
41018 void *argp1 = 0 ;
41019 int res1 = 0 ;
41020 PyObject *swig_obj[1] ;
41021
41022 if (!args) SWIG_fail;
41023 swig_obj[0] = args;
41024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41025 if (!SWIG_IsOK(res1)) {
41026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41027 }
41028 arg1 = reinterpret_cast< wxWindow * >(argp1);
41029 {
41030 PyThreadState* __tstate = wxPyBeginAllowThreads();
41031 result = (bool)(arg1)->CanSetTransparent();
41032 wxPyEndAllowThreads(__tstate);
41033 if (PyErr_Occurred()) SWIG_fail;
41034 }
41035 {
41036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41037 }
41038 return resultobj;
41039 fail:
41040 return NULL;
41041 }
41042
41043
41044 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41045 PyObject *resultobj = 0;
41046 wxWindow *arg1 = (wxWindow *) 0 ;
41047 byte arg2 ;
41048 bool result;
41049 void *argp1 = 0 ;
41050 int res1 = 0 ;
41051 unsigned char val2 ;
41052 int ecode2 = 0 ;
41053 PyObject * obj0 = 0 ;
41054 PyObject * obj1 = 0 ;
41055 char * kwnames[] = {
41056 (char *) "self",(char *) "alpha", NULL
41057 };
41058
41059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41061 if (!SWIG_IsOK(res1)) {
41062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41063 }
41064 arg1 = reinterpret_cast< wxWindow * >(argp1);
41065 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41066 if (!SWIG_IsOK(ecode2)) {
41067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41068 }
41069 arg2 = static_cast< byte >(val2);
41070 {
41071 PyThreadState* __tstate = wxPyBeginAllowThreads();
41072 result = (bool)(arg1)->SetTransparent(arg2);
41073 wxPyEndAllowThreads(__tstate);
41074 if (PyErr_Occurred()) SWIG_fail;
41075 }
41076 {
41077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41078 }
41079 return resultobj;
41080 fail:
41081 return NULL;
41082 }
41083
41084
41085 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41086 PyObject *obj;
41087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41088 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41089 return SWIG_Py_Void();
41090 }
41091
41092 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41093 return SWIG_Python_InitShadowInstance(args);
41094 }
41095
41096 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41097 PyObject *resultobj = 0;
41098 long arg1 ;
41099 wxWindow *arg2 = (wxWindow *) NULL ;
41100 wxWindow *result = 0 ;
41101 long val1 ;
41102 int ecode1 = 0 ;
41103 void *argp2 = 0 ;
41104 int res2 = 0 ;
41105 PyObject * obj0 = 0 ;
41106 PyObject * obj1 = 0 ;
41107 char * kwnames[] = {
41108 (char *) "id",(char *) "parent", NULL
41109 };
41110
41111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41112 ecode1 = SWIG_AsVal_long(obj0, &val1);
41113 if (!SWIG_IsOK(ecode1)) {
41114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41115 }
41116 arg1 = static_cast< long >(val1);
41117 if (obj1) {
41118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41119 if (!SWIG_IsOK(res2)) {
41120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41121 }
41122 arg2 = reinterpret_cast< wxWindow * >(argp2);
41123 }
41124 {
41125 if (!wxPyCheckForApp()) SWIG_fail;
41126 PyThreadState* __tstate = wxPyBeginAllowThreads();
41127 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41128 wxPyEndAllowThreads(__tstate);
41129 if (PyErr_Occurred()) SWIG_fail;
41130 }
41131 {
41132 resultobj = wxPyMake_wxObject(result, 0);
41133 }
41134 return resultobj;
41135 fail:
41136 return NULL;
41137 }
41138
41139
41140 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj = 0;
41142 wxString *arg1 = 0 ;
41143 wxWindow *arg2 = (wxWindow *) NULL ;
41144 wxWindow *result = 0 ;
41145 bool temp1 = false ;
41146 void *argp2 = 0 ;
41147 int res2 = 0 ;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 char * kwnames[] = {
41151 (char *) "name",(char *) "parent", NULL
41152 };
41153
41154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41155 {
41156 arg1 = wxString_in_helper(obj0);
41157 if (arg1 == NULL) SWIG_fail;
41158 temp1 = true;
41159 }
41160 if (obj1) {
41161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41162 if (!SWIG_IsOK(res2)) {
41163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41164 }
41165 arg2 = reinterpret_cast< wxWindow * >(argp2);
41166 }
41167 {
41168 if (!wxPyCheckForApp()) SWIG_fail;
41169 PyThreadState* __tstate = wxPyBeginAllowThreads();
41170 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41171 wxPyEndAllowThreads(__tstate);
41172 if (PyErr_Occurred()) SWIG_fail;
41173 }
41174 {
41175 resultobj = wxPyMake_wxObject(result, 0);
41176 }
41177 {
41178 if (temp1)
41179 delete arg1;
41180 }
41181 return resultobj;
41182 fail:
41183 {
41184 if (temp1)
41185 delete arg1;
41186 }
41187 return NULL;
41188 }
41189
41190
41191 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41192 PyObject *resultobj = 0;
41193 wxString *arg1 = 0 ;
41194 wxWindow *arg2 = (wxWindow *) NULL ;
41195 wxWindow *result = 0 ;
41196 bool temp1 = false ;
41197 void *argp2 = 0 ;
41198 int res2 = 0 ;
41199 PyObject * obj0 = 0 ;
41200 PyObject * obj1 = 0 ;
41201 char * kwnames[] = {
41202 (char *) "label",(char *) "parent", NULL
41203 };
41204
41205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41206 {
41207 arg1 = wxString_in_helper(obj0);
41208 if (arg1 == NULL) SWIG_fail;
41209 temp1 = true;
41210 }
41211 if (obj1) {
41212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41213 if (!SWIG_IsOK(res2)) {
41214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41215 }
41216 arg2 = reinterpret_cast< wxWindow * >(argp2);
41217 }
41218 {
41219 if (!wxPyCheckForApp()) SWIG_fail;
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41222 wxPyEndAllowThreads(__tstate);
41223 if (PyErr_Occurred()) SWIG_fail;
41224 }
41225 {
41226 resultobj = wxPyMake_wxObject(result, 0);
41227 }
41228 {
41229 if (temp1)
41230 delete arg1;
41231 }
41232 return resultobj;
41233 fail:
41234 {
41235 if (temp1)
41236 delete arg1;
41237 }
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41243 PyObject *resultobj = 0;
41244 wxWindow *arg1 = (wxWindow *) 0 ;
41245 unsigned long arg2 ;
41246 wxWindow *result = 0 ;
41247 void *argp1 = 0 ;
41248 int res1 = 0 ;
41249 unsigned long val2 ;
41250 int ecode2 = 0 ;
41251 PyObject * obj0 = 0 ;
41252 PyObject * obj1 = 0 ;
41253 char * kwnames[] = {
41254 (char *) "parent",(char *) "_hWnd", NULL
41255 };
41256
41257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41259 if (!SWIG_IsOK(res1)) {
41260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41261 }
41262 arg1 = reinterpret_cast< wxWindow * >(argp1);
41263 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41264 if (!SWIG_IsOK(ecode2)) {
41265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41266 }
41267 arg2 = static_cast< unsigned long >(val2);
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 {
41275 resultobj = wxPyMake_wxObject(result, 0);
41276 }
41277 return resultobj;
41278 fail:
41279 return NULL;
41280 }
41281
41282
41283 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41284 PyObject *resultobj = 0;
41285 PyObject *result = 0 ;
41286
41287 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41288 {
41289 PyThreadState* __tstate = wxPyBeginAllowThreads();
41290 result = (PyObject *)GetTopLevelWindows();
41291 wxPyEndAllowThreads(__tstate);
41292 if (PyErr_Occurred()) SWIG_fail;
41293 }
41294 resultobj = result;
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41302 PyObject *resultobj = 0;
41303 wxValidator *result = 0 ;
41304
41305 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41306 {
41307 PyThreadState* __tstate = wxPyBeginAllowThreads();
41308 result = (wxValidator *)new wxValidator();
41309 wxPyEndAllowThreads(__tstate);
41310 if (PyErr_Occurred()) SWIG_fail;
41311 }
41312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41313 return resultobj;
41314 fail:
41315 return NULL;
41316 }
41317
41318
41319 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41320 PyObject *resultobj = 0;
41321 wxValidator *arg1 = (wxValidator *) 0 ;
41322 wxValidator *result = 0 ;
41323 void *argp1 = 0 ;
41324 int res1 = 0 ;
41325 PyObject *swig_obj[1] ;
41326
41327 if (!args) SWIG_fail;
41328 swig_obj[0] = args;
41329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41330 if (!SWIG_IsOK(res1)) {
41331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41332 }
41333 arg1 = reinterpret_cast< wxValidator * >(argp1);
41334 {
41335 PyThreadState* __tstate = wxPyBeginAllowThreads();
41336 result = (wxValidator *)(arg1)->Clone();
41337 wxPyEndAllowThreads(__tstate);
41338 if (PyErr_Occurred()) SWIG_fail;
41339 }
41340 {
41341 resultobj = wxPyMake_wxObject(result, 0);
41342 }
41343 return resultobj;
41344 fail:
41345 return NULL;
41346 }
41347
41348
41349 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41350 PyObject *resultobj = 0;
41351 wxValidator *arg1 = (wxValidator *) 0 ;
41352 wxWindow *arg2 = (wxWindow *) 0 ;
41353 bool result;
41354 void *argp1 = 0 ;
41355 int res1 = 0 ;
41356 void *argp2 = 0 ;
41357 int res2 = 0 ;
41358 PyObject * obj0 = 0 ;
41359 PyObject * obj1 = 0 ;
41360 char * kwnames[] = {
41361 (char *) "self",(char *) "parent", NULL
41362 };
41363
41364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41366 if (!SWIG_IsOK(res1)) {
41367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41368 }
41369 arg1 = reinterpret_cast< wxValidator * >(argp1);
41370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41371 if (!SWIG_IsOK(res2)) {
41372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41373 }
41374 arg2 = reinterpret_cast< wxWindow * >(argp2);
41375 {
41376 PyThreadState* __tstate = wxPyBeginAllowThreads();
41377 result = (bool)(arg1)->Validate(arg2);
41378 wxPyEndAllowThreads(__tstate);
41379 if (PyErr_Occurred()) SWIG_fail;
41380 }
41381 {
41382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41383 }
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41391 PyObject *resultobj = 0;
41392 wxValidator *arg1 = (wxValidator *) 0 ;
41393 bool result;
41394 void *argp1 = 0 ;
41395 int res1 = 0 ;
41396 PyObject *swig_obj[1] ;
41397
41398 if (!args) SWIG_fail;
41399 swig_obj[0] = args;
41400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41401 if (!SWIG_IsOK(res1)) {
41402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41403 }
41404 arg1 = reinterpret_cast< wxValidator * >(argp1);
41405 {
41406 PyThreadState* __tstate = wxPyBeginAllowThreads();
41407 result = (bool)(arg1)->TransferToWindow();
41408 wxPyEndAllowThreads(__tstate);
41409 if (PyErr_Occurred()) SWIG_fail;
41410 }
41411 {
41412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41413 }
41414 return resultobj;
41415 fail:
41416 return NULL;
41417 }
41418
41419
41420 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41421 PyObject *resultobj = 0;
41422 wxValidator *arg1 = (wxValidator *) 0 ;
41423 bool result;
41424 void *argp1 = 0 ;
41425 int res1 = 0 ;
41426 PyObject *swig_obj[1] ;
41427
41428 if (!args) SWIG_fail;
41429 swig_obj[0] = args;
41430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41431 if (!SWIG_IsOK(res1)) {
41432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41433 }
41434 arg1 = reinterpret_cast< wxValidator * >(argp1);
41435 {
41436 PyThreadState* __tstate = wxPyBeginAllowThreads();
41437 result = (bool)(arg1)->TransferFromWindow();
41438 wxPyEndAllowThreads(__tstate);
41439 if (PyErr_Occurred()) SWIG_fail;
41440 }
41441 {
41442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41443 }
41444 return resultobj;
41445 fail:
41446 return NULL;
41447 }
41448
41449
41450 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41451 PyObject *resultobj = 0;
41452 wxValidator *arg1 = (wxValidator *) 0 ;
41453 wxWindow *result = 0 ;
41454 void *argp1 = 0 ;
41455 int res1 = 0 ;
41456 PyObject *swig_obj[1] ;
41457
41458 if (!args) SWIG_fail;
41459 swig_obj[0] = args;
41460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41461 if (!SWIG_IsOK(res1)) {
41462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41463 }
41464 arg1 = reinterpret_cast< wxValidator * >(argp1);
41465 {
41466 PyThreadState* __tstate = wxPyBeginAllowThreads();
41467 result = (wxWindow *)(arg1)->GetWindow();
41468 wxPyEndAllowThreads(__tstate);
41469 if (PyErr_Occurred()) SWIG_fail;
41470 }
41471 {
41472 resultobj = wxPyMake_wxObject(result, 0);
41473 }
41474 return resultobj;
41475 fail:
41476 return NULL;
41477 }
41478
41479
41480 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41481 PyObject *resultobj = 0;
41482 wxValidator *arg1 = (wxValidator *) 0 ;
41483 wxWindow *arg2 = (wxWindow *) 0 ;
41484 void *argp1 = 0 ;
41485 int res1 = 0 ;
41486 void *argp2 = 0 ;
41487 int res2 = 0 ;
41488 PyObject * obj0 = 0 ;
41489 PyObject * obj1 = 0 ;
41490 char * kwnames[] = {
41491 (char *) "self",(char *) "window", NULL
41492 };
41493
41494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41496 if (!SWIG_IsOK(res1)) {
41497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41498 }
41499 arg1 = reinterpret_cast< wxValidator * >(argp1);
41500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41501 if (!SWIG_IsOK(res2)) {
41502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41503 }
41504 arg2 = reinterpret_cast< wxWindow * >(argp2);
41505 {
41506 PyThreadState* __tstate = wxPyBeginAllowThreads();
41507 (arg1)->SetWindow(arg2);
41508 wxPyEndAllowThreads(__tstate);
41509 if (PyErr_Occurred()) SWIG_fail;
41510 }
41511 resultobj = SWIG_Py_Void();
41512 return resultobj;
41513 fail:
41514 return NULL;
41515 }
41516
41517
41518 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41519 PyObject *resultobj = 0;
41520 bool result;
41521
41522 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41523 {
41524 PyThreadState* __tstate = wxPyBeginAllowThreads();
41525 result = (bool)wxValidator::IsSilent();
41526 wxPyEndAllowThreads(__tstate);
41527 if (PyErr_Occurred()) SWIG_fail;
41528 }
41529 {
41530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41531 }
41532 return resultobj;
41533 fail:
41534 return NULL;
41535 }
41536
41537
41538 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41539 PyObject *resultobj = 0;
41540 int arg1 = (int) true ;
41541 int val1 ;
41542 int ecode1 = 0 ;
41543 PyObject * obj0 = 0 ;
41544 char * kwnames[] = {
41545 (char *) "doIt", NULL
41546 };
41547
41548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41549 if (obj0) {
41550 ecode1 = SWIG_AsVal_int(obj0, &val1);
41551 if (!SWIG_IsOK(ecode1)) {
41552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41553 }
41554 arg1 = static_cast< int >(val1);
41555 }
41556 {
41557 PyThreadState* __tstate = wxPyBeginAllowThreads();
41558 wxValidator::SetBellOnError(arg1);
41559 wxPyEndAllowThreads(__tstate);
41560 if (PyErr_Occurred()) SWIG_fail;
41561 }
41562 resultobj = SWIG_Py_Void();
41563 return resultobj;
41564 fail:
41565 return NULL;
41566 }
41567
41568
41569 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41570 PyObject *obj;
41571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41572 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41573 return SWIG_Py_Void();
41574 }
41575
41576 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41577 return SWIG_Python_InitShadowInstance(args);
41578 }
41579
41580 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41581 PyObject *resultobj = 0;
41582 wxPyValidator *result = 0 ;
41583
41584 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41585 {
41586 PyThreadState* __tstate = wxPyBeginAllowThreads();
41587 result = (wxPyValidator *)new wxPyValidator();
41588 wxPyEndAllowThreads(__tstate);
41589 if (PyErr_Occurred()) SWIG_fail;
41590 }
41591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41592 return resultobj;
41593 fail:
41594 return NULL;
41595 }
41596
41597
41598 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41599 PyObject *resultobj = 0;
41600 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41601 PyObject *arg2 = (PyObject *) 0 ;
41602 PyObject *arg3 = (PyObject *) 0 ;
41603 int arg4 = (int) true ;
41604 void *argp1 = 0 ;
41605 int res1 = 0 ;
41606 int val4 ;
41607 int ecode4 = 0 ;
41608 PyObject * obj0 = 0 ;
41609 PyObject * obj1 = 0 ;
41610 PyObject * obj2 = 0 ;
41611 PyObject * obj3 = 0 ;
41612 char * kwnames[] = {
41613 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41614 };
41615
41616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41618 if (!SWIG_IsOK(res1)) {
41619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41620 }
41621 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41622 arg2 = obj1;
41623 arg3 = obj2;
41624 if (obj3) {
41625 ecode4 = SWIG_AsVal_int(obj3, &val4);
41626 if (!SWIG_IsOK(ecode4)) {
41627 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41628 }
41629 arg4 = static_cast< int >(val4);
41630 }
41631 {
41632 PyThreadState* __tstate = wxPyBeginAllowThreads();
41633 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 resultobj = SWIG_Py_Void();
41638 return resultobj;
41639 fail:
41640 return NULL;
41641 }
41642
41643
41644 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41645 PyObject *obj;
41646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41647 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41648 return SWIG_Py_Void();
41649 }
41650
41651 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41652 return SWIG_Python_InitShadowInstance(args);
41653 }
41654
41655 SWIGINTERN int DefaultValidator_set(PyObject *) {
41656 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41657 return 1;
41658 }
41659
41660
41661 SWIGINTERN PyObject *DefaultValidator_get(void) {
41662 PyObject *pyobj = 0;
41663
41664 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41665 return pyobj;
41666 }
41667
41668
41669 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41670 PyObject *resultobj = 0;
41671 wxString const &arg1_defvalue = wxPyEmptyString ;
41672 wxString *arg1 = (wxString *) &arg1_defvalue ;
41673 long arg2 = (long) 0 ;
41674 wxMenu *result = 0 ;
41675 bool temp1 = false ;
41676 long val2 ;
41677 int ecode2 = 0 ;
41678 PyObject * obj0 = 0 ;
41679 PyObject * obj1 = 0 ;
41680 char * kwnames[] = {
41681 (char *) "title",(char *) "style", NULL
41682 };
41683
41684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41685 if (obj0) {
41686 {
41687 arg1 = wxString_in_helper(obj0);
41688 if (arg1 == NULL) SWIG_fail;
41689 temp1 = true;
41690 }
41691 }
41692 if (obj1) {
41693 ecode2 = SWIG_AsVal_long(obj1, &val2);
41694 if (!SWIG_IsOK(ecode2)) {
41695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41696 }
41697 arg2 = static_cast< long >(val2);
41698 }
41699 {
41700 if (!wxPyCheckForApp()) SWIG_fail;
41701 PyThreadState* __tstate = wxPyBeginAllowThreads();
41702 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41703 wxPyEndAllowThreads(__tstate);
41704 if (PyErr_Occurred()) SWIG_fail;
41705 }
41706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41707 {
41708 if (temp1)
41709 delete arg1;
41710 }
41711 return resultobj;
41712 fail:
41713 {
41714 if (temp1)
41715 delete arg1;
41716 }
41717 return NULL;
41718 }
41719
41720
41721 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41722 PyObject *resultobj = 0;
41723 wxMenu *arg1 = (wxMenu *) 0 ;
41724 int arg2 ;
41725 wxString const &arg3_defvalue = wxPyEmptyString ;
41726 wxString *arg3 = (wxString *) &arg3_defvalue ;
41727 wxString const &arg4_defvalue = wxPyEmptyString ;
41728 wxString *arg4 = (wxString *) &arg4_defvalue ;
41729 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41730 wxMenuItem *result = 0 ;
41731 void *argp1 = 0 ;
41732 int res1 = 0 ;
41733 int val2 ;
41734 int ecode2 = 0 ;
41735 bool temp3 = false ;
41736 bool temp4 = false ;
41737 int val5 ;
41738 int ecode5 = 0 ;
41739 PyObject * obj0 = 0 ;
41740 PyObject * obj1 = 0 ;
41741 PyObject * obj2 = 0 ;
41742 PyObject * obj3 = 0 ;
41743 PyObject * obj4 = 0 ;
41744 char * kwnames[] = {
41745 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41746 };
41747
41748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41750 if (!SWIG_IsOK(res1)) {
41751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41752 }
41753 arg1 = reinterpret_cast< wxMenu * >(argp1);
41754 ecode2 = SWIG_AsVal_int(obj1, &val2);
41755 if (!SWIG_IsOK(ecode2)) {
41756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41757 }
41758 arg2 = static_cast< int >(val2);
41759 if (obj2) {
41760 {
41761 arg3 = wxString_in_helper(obj2);
41762 if (arg3 == NULL) SWIG_fail;
41763 temp3 = true;
41764 }
41765 }
41766 if (obj3) {
41767 {
41768 arg4 = wxString_in_helper(obj3);
41769 if (arg4 == NULL) SWIG_fail;
41770 temp4 = true;
41771 }
41772 }
41773 if (obj4) {
41774 ecode5 = SWIG_AsVal_int(obj4, &val5);
41775 if (!SWIG_IsOK(ecode5)) {
41776 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41777 }
41778 arg5 = static_cast< wxItemKind >(val5);
41779 }
41780 {
41781 PyThreadState* __tstate = wxPyBeginAllowThreads();
41782 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41783 wxPyEndAllowThreads(__tstate);
41784 if (PyErr_Occurred()) SWIG_fail;
41785 }
41786 {
41787 resultobj = wxPyMake_wxObject(result, (bool)0);
41788 }
41789 {
41790 if (temp3)
41791 delete arg3;
41792 }
41793 {
41794 if (temp4)
41795 delete arg4;
41796 }
41797 return resultobj;
41798 fail:
41799 {
41800 if (temp3)
41801 delete arg3;
41802 }
41803 {
41804 if (temp4)
41805 delete arg4;
41806 }
41807 return NULL;
41808 }
41809
41810
41811 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41812 PyObject *resultobj = 0;
41813 wxMenu *arg1 = (wxMenu *) 0 ;
41814 wxMenuItem *result = 0 ;
41815 void *argp1 = 0 ;
41816 int res1 = 0 ;
41817 PyObject *swig_obj[1] ;
41818
41819 if (!args) SWIG_fail;
41820 swig_obj[0] = args;
41821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41822 if (!SWIG_IsOK(res1)) {
41823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41824 }
41825 arg1 = reinterpret_cast< wxMenu * >(argp1);
41826 {
41827 PyThreadState* __tstate = wxPyBeginAllowThreads();
41828 result = (wxMenuItem *)(arg1)->AppendSeparator();
41829 wxPyEndAllowThreads(__tstate);
41830 if (PyErr_Occurred()) SWIG_fail;
41831 }
41832 {
41833 resultobj = wxPyMake_wxObject(result, (bool)0);
41834 }
41835 return resultobj;
41836 fail:
41837 return NULL;
41838 }
41839
41840
41841 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41842 PyObject *resultobj = 0;
41843 wxMenu *arg1 = (wxMenu *) 0 ;
41844 int arg2 ;
41845 wxString *arg3 = 0 ;
41846 wxString const &arg4_defvalue = wxPyEmptyString ;
41847 wxString *arg4 = (wxString *) &arg4_defvalue ;
41848 wxMenuItem *result = 0 ;
41849 void *argp1 = 0 ;
41850 int res1 = 0 ;
41851 int val2 ;
41852 int ecode2 = 0 ;
41853 bool temp3 = false ;
41854 bool temp4 = false ;
41855 PyObject * obj0 = 0 ;
41856 PyObject * obj1 = 0 ;
41857 PyObject * obj2 = 0 ;
41858 PyObject * obj3 = 0 ;
41859 char * kwnames[] = {
41860 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41861 };
41862
41863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41865 if (!SWIG_IsOK(res1)) {
41866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41867 }
41868 arg1 = reinterpret_cast< wxMenu * >(argp1);
41869 ecode2 = SWIG_AsVal_int(obj1, &val2);
41870 if (!SWIG_IsOK(ecode2)) {
41871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41872 }
41873 arg2 = static_cast< int >(val2);
41874 {
41875 arg3 = wxString_in_helper(obj2);
41876 if (arg3 == NULL) SWIG_fail;
41877 temp3 = true;
41878 }
41879 if (obj3) {
41880 {
41881 arg4 = wxString_in_helper(obj3);
41882 if (arg4 == NULL) SWIG_fail;
41883 temp4 = true;
41884 }
41885 }
41886 {
41887 PyThreadState* __tstate = wxPyBeginAllowThreads();
41888 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41889 wxPyEndAllowThreads(__tstate);
41890 if (PyErr_Occurred()) SWIG_fail;
41891 }
41892 {
41893 resultobj = wxPyMake_wxObject(result, (bool)0);
41894 }
41895 {
41896 if (temp3)
41897 delete arg3;
41898 }
41899 {
41900 if (temp4)
41901 delete arg4;
41902 }
41903 return resultobj;
41904 fail:
41905 {
41906 if (temp3)
41907 delete arg3;
41908 }
41909 {
41910 if (temp4)
41911 delete arg4;
41912 }
41913 return NULL;
41914 }
41915
41916
41917 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41918 PyObject *resultobj = 0;
41919 wxMenu *arg1 = (wxMenu *) 0 ;
41920 int arg2 ;
41921 wxString *arg3 = 0 ;
41922 wxString const &arg4_defvalue = wxPyEmptyString ;
41923 wxString *arg4 = (wxString *) &arg4_defvalue ;
41924 wxMenuItem *result = 0 ;
41925 void *argp1 = 0 ;
41926 int res1 = 0 ;
41927 int val2 ;
41928 int ecode2 = 0 ;
41929 bool temp3 = false ;
41930 bool temp4 = false ;
41931 PyObject * obj0 = 0 ;
41932 PyObject * obj1 = 0 ;
41933 PyObject * obj2 = 0 ;
41934 PyObject * obj3 = 0 ;
41935 char * kwnames[] = {
41936 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41937 };
41938
41939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41941 if (!SWIG_IsOK(res1)) {
41942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41943 }
41944 arg1 = reinterpret_cast< wxMenu * >(argp1);
41945 ecode2 = SWIG_AsVal_int(obj1, &val2);
41946 if (!SWIG_IsOK(ecode2)) {
41947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41948 }
41949 arg2 = static_cast< int >(val2);
41950 {
41951 arg3 = wxString_in_helper(obj2);
41952 if (arg3 == NULL) SWIG_fail;
41953 temp3 = true;
41954 }
41955 if (obj3) {
41956 {
41957 arg4 = wxString_in_helper(obj3);
41958 if (arg4 == NULL) SWIG_fail;
41959 temp4 = true;
41960 }
41961 }
41962 {
41963 PyThreadState* __tstate = wxPyBeginAllowThreads();
41964 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41965 wxPyEndAllowThreads(__tstate);
41966 if (PyErr_Occurred()) SWIG_fail;
41967 }
41968 {
41969 resultobj = wxPyMake_wxObject(result, (bool)0);
41970 }
41971 {
41972 if (temp3)
41973 delete arg3;
41974 }
41975 {
41976 if (temp4)
41977 delete arg4;
41978 }
41979 return resultobj;
41980 fail:
41981 {
41982 if (temp3)
41983 delete arg3;
41984 }
41985 {
41986 if (temp4)
41987 delete arg4;
41988 }
41989 return NULL;
41990 }
41991
41992
41993 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41994 PyObject *resultobj = 0;
41995 wxMenu *arg1 = (wxMenu *) 0 ;
41996 int arg2 ;
41997 wxString *arg3 = 0 ;
41998 wxMenu *arg4 = (wxMenu *) 0 ;
41999 wxString const &arg5_defvalue = wxPyEmptyString ;
42000 wxString *arg5 = (wxString *) &arg5_defvalue ;
42001 wxMenuItem *result = 0 ;
42002 void *argp1 = 0 ;
42003 int res1 = 0 ;
42004 int val2 ;
42005 int ecode2 = 0 ;
42006 bool temp3 = false ;
42007 void *argp4 = 0 ;
42008 int res4 = 0 ;
42009 bool temp5 = false ;
42010 PyObject * obj0 = 0 ;
42011 PyObject * obj1 = 0 ;
42012 PyObject * obj2 = 0 ;
42013 PyObject * obj3 = 0 ;
42014 PyObject * obj4 = 0 ;
42015 char * kwnames[] = {
42016 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42017 };
42018
42019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42021 if (!SWIG_IsOK(res1)) {
42022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42023 }
42024 arg1 = reinterpret_cast< wxMenu * >(argp1);
42025 ecode2 = SWIG_AsVal_int(obj1, &val2);
42026 if (!SWIG_IsOK(ecode2)) {
42027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42028 }
42029 arg2 = static_cast< int >(val2);
42030 {
42031 arg3 = wxString_in_helper(obj2);
42032 if (arg3 == NULL) SWIG_fail;
42033 temp3 = true;
42034 }
42035 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42036 if (!SWIG_IsOK(res4)) {
42037 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42038 }
42039 arg4 = reinterpret_cast< wxMenu * >(argp4);
42040 if (obj4) {
42041 {
42042 arg5 = wxString_in_helper(obj4);
42043 if (arg5 == NULL) SWIG_fail;
42044 temp5 = true;
42045 }
42046 }
42047 {
42048 PyThreadState* __tstate = wxPyBeginAllowThreads();
42049 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42050 wxPyEndAllowThreads(__tstate);
42051 if (PyErr_Occurred()) SWIG_fail;
42052 }
42053 {
42054 resultobj = wxPyMake_wxObject(result, (bool)0);
42055 }
42056 {
42057 if (temp3)
42058 delete arg3;
42059 }
42060 {
42061 if (temp5)
42062 delete arg5;
42063 }
42064 return resultobj;
42065 fail:
42066 {
42067 if (temp3)
42068 delete arg3;
42069 }
42070 {
42071 if (temp5)
42072 delete arg5;
42073 }
42074 return NULL;
42075 }
42076
42077
42078 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42079 PyObject *resultobj = 0;
42080 wxMenu *arg1 = (wxMenu *) 0 ;
42081 wxMenu *arg2 = (wxMenu *) 0 ;
42082 wxString *arg3 = 0 ;
42083 wxString const &arg4_defvalue = wxPyEmptyString ;
42084 wxString *arg4 = (wxString *) &arg4_defvalue ;
42085 wxMenuItem *result = 0 ;
42086 void *argp1 = 0 ;
42087 int res1 = 0 ;
42088 void *argp2 = 0 ;
42089 int res2 = 0 ;
42090 bool temp3 = false ;
42091 bool temp4 = false ;
42092 PyObject * obj0 = 0 ;
42093 PyObject * obj1 = 0 ;
42094 PyObject * obj2 = 0 ;
42095 PyObject * obj3 = 0 ;
42096 char * kwnames[] = {
42097 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42098 };
42099
42100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42102 if (!SWIG_IsOK(res1)) {
42103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42104 }
42105 arg1 = reinterpret_cast< wxMenu * >(argp1);
42106 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42107 if (!SWIG_IsOK(res2)) {
42108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42109 }
42110 arg2 = reinterpret_cast< wxMenu * >(argp2);
42111 {
42112 arg3 = wxString_in_helper(obj2);
42113 if (arg3 == NULL) SWIG_fail;
42114 temp3 = true;
42115 }
42116 if (obj3) {
42117 {
42118 arg4 = wxString_in_helper(obj3);
42119 if (arg4 == NULL) SWIG_fail;
42120 temp4 = true;
42121 }
42122 }
42123 {
42124 PyThreadState* __tstate = wxPyBeginAllowThreads();
42125 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42126 wxPyEndAllowThreads(__tstate);
42127 if (PyErr_Occurred()) SWIG_fail;
42128 }
42129 {
42130 resultobj = wxPyMake_wxObject(result, (bool)0);
42131 }
42132 {
42133 if (temp3)
42134 delete arg3;
42135 }
42136 {
42137 if (temp4)
42138 delete arg4;
42139 }
42140 return resultobj;
42141 fail:
42142 {
42143 if (temp3)
42144 delete arg3;
42145 }
42146 {
42147 if (temp4)
42148 delete arg4;
42149 }
42150 return NULL;
42151 }
42152
42153
42154 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42155 PyObject *resultobj = 0;
42156 wxMenu *arg1 = (wxMenu *) 0 ;
42157 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42158 wxMenuItem *result = 0 ;
42159 void *argp1 = 0 ;
42160 int res1 = 0 ;
42161 int res2 = 0 ;
42162 PyObject * obj0 = 0 ;
42163 PyObject * obj1 = 0 ;
42164 char * kwnames[] = {
42165 (char *) "self",(char *) "item", NULL
42166 };
42167
42168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42170 if (!SWIG_IsOK(res1)) {
42171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42172 }
42173 arg1 = reinterpret_cast< wxMenu * >(argp1);
42174 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42175 if (!SWIG_IsOK(res2)) {
42176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42177 }
42178 {
42179 PyThreadState* __tstate = wxPyBeginAllowThreads();
42180 result = (wxMenuItem *)(arg1)->Append(arg2);
42181 wxPyEndAllowThreads(__tstate);
42182 if (PyErr_Occurred()) SWIG_fail;
42183 }
42184 {
42185 resultobj = wxPyMake_wxObject(result, (bool)0);
42186 }
42187 return resultobj;
42188 fail:
42189 return NULL;
42190 }
42191
42192
42193 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42194 PyObject *resultobj = 0;
42195 wxMenu *arg1 = (wxMenu *) 0 ;
42196 size_t arg2 ;
42197 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42198 wxMenuItem *result = 0 ;
42199 void *argp1 = 0 ;
42200 int res1 = 0 ;
42201 size_t val2 ;
42202 int ecode2 = 0 ;
42203 int res3 = 0 ;
42204 PyObject * obj0 = 0 ;
42205 PyObject * obj1 = 0 ;
42206 PyObject * obj2 = 0 ;
42207 char * kwnames[] = {
42208 (char *) "self",(char *) "pos",(char *) "item", NULL
42209 };
42210
42211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42213 if (!SWIG_IsOK(res1)) {
42214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42215 }
42216 arg1 = reinterpret_cast< wxMenu * >(argp1);
42217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42218 if (!SWIG_IsOK(ecode2)) {
42219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42220 }
42221 arg2 = static_cast< size_t >(val2);
42222 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42223 if (!SWIG_IsOK(res3)) {
42224 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42225 }
42226 {
42227 PyThreadState* __tstate = wxPyBeginAllowThreads();
42228 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42229 wxPyEndAllowThreads(__tstate);
42230 if (PyErr_Occurred()) SWIG_fail;
42231 }
42232 {
42233 resultobj = wxPyMake_wxObject(result, (bool)0);
42234 }
42235 return resultobj;
42236 fail:
42237 return NULL;
42238 }
42239
42240
42241 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42242 PyObject *resultobj = 0;
42243 wxMenu *arg1 = (wxMenu *) 0 ;
42244 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42245 wxMenuItem *result = 0 ;
42246 void *argp1 = 0 ;
42247 int res1 = 0 ;
42248 int res2 = 0 ;
42249 PyObject * obj0 = 0 ;
42250 PyObject * obj1 = 0 ;
42251 char * kwnames[] = {
42252 (char *) "self",(char *) "item", NULL
42253 };
42254
42255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42257 if (!SWIG_IsOK(res1)) {
42258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42259 }
42260 arg1 = reinterpret_cast< wxMenu * >(argp1);
42261 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42262 if (!SWIG_IsOK(res2)) {
42263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42264 }
42265 {
42266 PyThreadState* __tstate = wxPyBeginAllowThreads();
42267 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42268 wxPyEndAllowThreads(__tstate);
42269 if (PyErr_Occurred()) SWIG_fail;
42270 }
42271 {
42272 resultobj = wxPyMake_wxObject(result, (bool)0);
42273 }
42274 return resultobj;
42275 fail:
42276 return NULL;
42277 }
42278
42279
42280 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42281 PyObject *resultobj = 0;
42282 wxMenu *arg1 = (wxMenu *) 0 ;
42283 void *argp1 = 0 ;
42284 int res1 = 0 ;
42285 PyObject *swig_obj[1] ;
42286
42287 if (!args) SWIG_fail;
42288 swig_obj[0] = args;
42289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42290 if (!SWIG_IsOK(res1)) {
42291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42292 }
42293 arg1 = reinterpret_cast< wxMenu * >(argp1);
42294 {
42295 PyThreadState* __tstate = wxPyBeginAllowThreads();
42296 (arg1)->Break();
42297 wxPyEndAllowThreads(__tstate);
42298 if (PyErr_Occurred()) SWIG_fail;
42299 }
42300 resultobj = SWIG_Py_Void();
42301 return resultobj;
42302 fail:
42303 return NULL;
42304 }
42305
42306
42307 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42308 PyObject *resultobj = 0;
42309 wxMenu *arg1 = (wxMenu *) 0 ;
42310 size_t arg2 ;
42311 int arg3 ;
42312 wxString const &arg4_defvalue = wxPyEmptyString ;
42313 wxString *arg4 = (wxString *) &arg4_defvalue ;
42314 wxString const &arg5_defvalue = wxPyEmptyString ;
42315 wxString *arg5 = (wxString *) &arg5_defvalue ;
42316 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42317 wxMenuItem *result = 0 ;
42318 void *argp1 = 0 ;
42319 int res1 = 0 ;
42320 size_t val2 ;
42321 int ecode2 = 0 ;
42322 int val3 ;
42323 int ecode3 = 0 ;
42324 bool temp4 = false ;
42325 bool temp5 = false ;
42326 int val6 ;
42327 int ecode6 = 0 ;
42328 PyObject * obj0 = 0 ;
42329 PyObject * obj1 = 0 ;
42330 PyObject * obj2 = 0 ;
42331 PyObject * obj3 = 0 ;
42332 PyObject * obj4 = 0 ;
42333 PyObject * obj5 = 0 ;
42334 char * kwnames[] = {
42335 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42336 };
42337
42338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42340 if (!SWIG_IsOK(res1)) {
42341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42342 }
42343 arg1 = reinterpret_cast< wxMenu * >(argp1);
42344 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42345 if (!SWIG_IsOK(ecode2)) {
42346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42347 }
42348 arg2 = static_cast< size_t >(val2);
42349 ecode3 = SWIG_AsVal_int(obj2, &val3);
42350 if (!SWIG_IsOK(ecode3)) {
42351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42352 }
42353 arg3 = static_cast< int >(val3);
42354 if (obj3) {
42355 {
42356 arg4 = wxString_in_helper(obj3);
42357 if (arg4 == NULL) SWIG_fail;
42358 temp4 = true;
42359 }
42360 }
42361 if (obj4) {
42362 {
42363 arg5 = wxString_in_helper(obj4);
42364 if (arg5 == NULL) SWIG_fail;
42365 temp5 = true;
42366 }
42367 }
42368 if (obj5) {
42369 ecode6 = SWIG_AsVal_int(obj5, &val6);
42370 if (!SWIG_IsOK(ecode6)) {
42371 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42372 }
42373 arg6 = static_cast< wxItemKind >(val6);
42374 }
42375 {
42376 PyThreadState* __tstate = wxPyBeginAllowThreads();
42377 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42378 wxPyEndAllowThreads(__tstate);
42379 if (PyErr_Occurred()) SWIG_fail;
42380 }
42381 {
42382 resultobj = wxPyMake_wxObject(result, (bool)0);
42383 }
42384 {
42385 if (temp4)
42386 delete arg4;
42387 }
42388 {
42389 if (temp5)
42390 delete arg5;
42391 }
42392 return resultobj;
42393 fail:
42394 {
42395 if (temp4)
42396 delete arg4;
42397 }
42398 {
42399 if (temp5)
42400 delete arg5;
42401 }
42402 return NULL;
42403 }
42404
42405
42406 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42407 PyObject *resultobj = 0;
42408 wxMenu *arg1 = (wxMenu *) 0 ;
42409 size_t arg2 ;
42410 wxMenuItem *result = 0 ;
42411 void *argp1 = 0 ;
42412 int res1 = 0 ;
42413 size_t val2 ;
42414 int ecode2 = 0 ;
42415 PyObject * obj0 = 0 ;
42416 PyObject * obj1 = 0 ;
42417 char * kwnames[] = {
42418 (char *) "self",(char *) "pos", NULL
42419 };
42420
42421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42423 if (!SWIG_IsOK(res1)) {
42424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42425 }
42426 arg1 = reinterpret_cast< wxMenu * >(argp1);
42427 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42428 if (!SWIG_IsOK(ecode2)) {
42429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42430 }
42431 arg2 = static_cast< size_t >(val2);
42432 {
42433 PyThreadState* __tstate = wxPyBeginAllowThreads();
42434 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42435 wxPyEndAllowThreads(__tstate);
42436 if (PyErr_Occurred()) SWIG_fail;
42437 }
42438 {
42439 resultobj = wxPyMake_wxObject(result, (bool)0);
42440 }
42441 return resultobj;
42442 fail:
42443 return NULL;
42444 }
42445
42446
42447 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42448 PyObject *resultobj = 0;
42449 wxMenu *arg1 = (wxMenu *) 0 ;
42450 size_t arg2 ;
42451 int arg3 ;
42452 wxString *arg4 = 0 ;
42453 wxString const &arg5_defvalue = wxPyEmptyString ;
42454 wxString *arg5 = (wxString *) &arg5_defvalue ;
42455 wxMenuItem *result = 0 ;
42456 void *argp1 = 0 ;
42457 int res1 = 0 ;
42458 size_t val2 ;
42459 int ecode2 = 0 ;
42460 int val3 ;
42461 int ecode3 = 0 ;
42462 bool temp4 = false ;
42463 bool temp5 = false ;
42464 PyObject * obj0 = 0 ;
42465 PyObject * obj1 = 0 ;
42466 PyObject * obj2 = 0 ;
42467 PyObject * obj3 = 0 ;
42468 PyObject * obj4 = 0 ;
42469 char * kwnames[] = {
42470 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42471 };
42472
42473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42475 if (!SWIG_IsOK(res1)) {
42476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42477 }
42478 arg1 = reinterpret_cast< wxMenu * >(argp1);
42479 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42480 if (!SWIG_IsOK(ecode2)) {
42481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42482 }
42483 arg2 = static_cast< size_t >(val2);
42484 ecode3 = SWIG_AsVal_int(obj2, &val3);
42485 if (!SWIG_IsOK(ecode3)) {
42486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42487 }
42488 arg3 = static_cast< int >(val3);
42489 {
42490 arg4 = wxString_in_helper(obj3);
42491 if (arg4 == NULL) SWIG_fail;
42492 temp4 = true;
42493 }
42494 if (obj4) {
42495 {
42496 arg5 = wxString_in_helper(obj4);
42497 if (arg5 == NULL) SWIG_fail;
42498 temp5 = true;
42499 }
42500 }
42501 {
42502 PyThreadState* __tstate = wxPyBeginAllowThreads();
42503 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42504 wxPyEndAllowThreads(__tstate);
42505 if (PyErr_Occurred()) SWIG_fail;
42506 }
42507 {
42508 resultobj = wxPyMake_wxObject(result, (bool)0);
42509 }
42510 {
42511 if (temp4)
42512 delete arg4;
42513 }
42514 {
42515 if (temp5)
42516 delete arg5;
42517 }
42518 return resultobj;
42519 fail:
42520 {
42521 if (temp4)
42522 delete arg4;
42523 }
42524 {
42525 if (temp5)
42526 delete arg5;
42527 }
42528 return NULL;
42529 }
42530
42531
42532 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42533 PyObject *resultobj = 0;
42534 wxMenu *arg1 = (wxMenu *) 0 ;
42535 size_t arg2 ;
42536 int arg3 ;
42537 wxString *arg4 = 0 ;
42538 wxString const &arg5_defvalue = wxPyEmptyString ;
42539 wxString *arg5 = (wxString *) &arg5_defvalue ;
42540 wxMenuItem *result = 0 ;
42541 void *argp1 = 0 ;
42542 int res1 = 0 ;
42543 size_t val2 ;
42544 int ecode2 = 0 ;
42545 int val3 ;
42546 int ecode3 = 0 ;
42547 bool temp4 = false ;
42548 bool temp5 = false ;
42549 PyObject * obj0 = 0 ;
42550 PyObject * obj1 = 0 ;
42551 PyObject * obj2 = 0 ;
42552 PyObject * obj3 = 0 ;
42553 PyObject * obj4 = 0 ;
42554 char * kwnames[] = {
42555 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42556 };
42557
42558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42560 if (!SWIG_IsOK(res1)) {
42561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42562 }
42563 arg1 = reinterpret_cast< wxMenu * >(argp1);
42564 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42565 if (!SWIG_IsOK(ecode2)) {
42566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42567 }
42568 arg2 = static_cast< size_t >(val2);
42569 ecode3 = SWIG_AsVal_int(obj2, &val3);
42570 if (!SWIG_IsOK(ecode3)) {
42571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42572 }
42573 arg3 = static_cast< int >(val3);
42574 {
42575 arg4 = wxString_in_helper(obj3);
42576 if (arg4 == NULL) SWIG_fail;
42577 temp4 = true;
42578 }
42579 if (obj4) {
42580 {
42581 arg5 = wxString_in_helper(obj4);
42582 if (arg5 == NULL) SWIG_fail;
42583 temp5 = true;
42584 }
42585 }
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 {
42593 resultobj = wxPyMake_wxObject(result, (bool)0);
42594 }
42595 {
42596 if (temp4)
42597 delete arg4;
42598 }
42599 {
42600 if (temp5)
42601 delete arg5;
42602 }
42603 return resultobj;
42604 fail:
42605 {
42606 if (temp4)
42607 delete arg4;
42608 }
42609 {
42610 if (temp5)
42611 delete arg5;
42612 }
42613 return NULL;
42614 }
42615
42616
42617 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42618 PyObject *resultobj = 0;
42619 wxMenu *arg1 = (wxMenu *) 0 ;
42620 size_t arg2 ;
42621 int arg3 ;
42622 wxString *arg4 = 0 ;
42623 wxMenu *arg5 = (wxMenu *) 0 ;
42624 wxString const &arg6_defvalue = wxPyEmptyString ;
42625 wxString *arg6 = (wxString *) &arg6_defvalue ;
42626 wxMenuItem *result = 0 ;
42627 void *argp1 = 0 ;
42628 int res1 = 0 ;
42629 size_t val2 ;
42630 int ecode2 = 0 ;
42631 int val3 ;
42632 int ecode3 = 0 ;
42633 bool temp4 = false ;
42634 void *argp5 = 0 ;
42635 int res5 = 0 ;
42636 bool temp6 = false ;
42637 PyObject * obj0 = 0 ;
42638 PyObject * obj1 = 0 ;
42639 PyObject * obj2 = 0 ;
42640 PyObject * obj3 = 0 ;
42641 PyObject * obj4 = 0 ;
42642 PyObject * obj5 = 0 ;
42643 char * kwnames[] = {
42644 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42645 };
42646
42647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42649 if (!SWIG_IsOK(res1)) {
42650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42651 }
42652 arg1 = reinterpret_cast< wxMenu * >(argp1);
42653 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42654 if (!SWIG_IsOK(ecode2)) {
42655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42656 }
42657 arg2 = static_cast< size_t >(val2);
42658 ecode3 = SWIG_AsVal_int(obj2, &val3);
42659 if (!SWIG_IsOK(ecode3)) {
42660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42661 }
42662 arg3 = static_cast< int >(val3);
42663 {
42664 arg4 = wxString_in_helper(obj3);
42665 if (arg4 == NULL) SWIG_fail;
42666 temp4 = true;
42667 }
42668 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42669 if (!SWIG_IsOK(res5)) {
42670 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42671 }
42672 arg5 = reinterpret_cast< wxMenu * >(argp5);
42673 if (obj5) {
42674 {
42675 arg6 = wxString_in_helper(obj5);
42676 if (arg6 == NULL) SWIG_fail;
42677 temp6 = true;
42678 }
42679 }
42680 {
42681 PyThreadState* __tstate = wxPyBeginAllowThreads();
42682 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42683 wxPyEndAllowThreads(__tstate);
42684 if (PyErr_Occurred()) SWIG_fail;
42685 }
42686 {
42687 resultobj = wxPyMake_wxObject(result, (bool)0);
42688 }
42689 {
42690 if (temp4)
42691 delete arg4;
42692 }
42693 {
42694 if (temp6)
42695 delete arg6;
42696 }
42697 return resultobj;
42698 fail:
42699 {
42700 if (temp4)
42701 delete arg4;
42702 }
42703 {
42704 if (temp6)
42705 delete arg6;
42706 }
42707 return NULL;
42708 }
42709
42710
42711 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42712 PyObject *resultobj = 0;
42713 wxMenu *arg1 = (wxMenu *) 0 ;
42714 int arg2 ;
42715 wxString const &arg3_defvalue = wxPyEmptyString ;
42716 wxString *arg3 = (wxString *) &arg3_defvalue ;
42717 wxString const &arg4_defvalue = wxPyEmptyString ;
42718 wxString *arg4 = (wxString *) &arg4_defvalue ;
42719 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42720 wxMenuItem *result = 0 ;
42721 void *argp1 = 0 ;
42722 int res1 = 0 ;
42723 int val2 ;
42724 int ecode2 = 0 ;
42725 bool temp3 = false ;
42726 bool temp4 = false ;
42727 int val5 ;
42728 int ecode5 = 0 ;
42729 PyObject * obj0 = 0 ;
42730 PyObject * obj1 = 0 ;
42731 PyObject * obj2 = 0 ;
42732 PyObject * obj3 = 0 ;
42733 PyObject * obj4 = 0 ;
42734 char * kwnames[] = {
42735 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42736 };
42737
42738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenu * >(argp1);
42744 ecode2 = SWIG_AsVal_int(obj1, &val2);
42745 if (!SWIG_IsOK(ecode2)) {
42746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42747 }
42748 arg2 = static_cast< int >(val2);
42749 if (obj2) {
42750 {
42751 arg3 = wxString_in_helper(obj2);
42752 if (arg3 == NULL) SWIG_fail;
42753 temp3 = true;
42754 }
42755 }
42756 if (obj3) {
42757 {
42758 arg4 = wxString_in_helper(obj3);
42759 if (arg4 == NULL) SWIG_fail;
42760 temp4 = true;
42761 }
42762 }
42763 if (obj4) {
42764 ecode5 = SWIG_AsVal_int(obj4, &val5);
42765 if (!SWIG_IsOK(ecode5)) {
42766 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42767 }
42768 arg5 = static_cast< wxItemKind >(val5);
42769 }
42770 {
42771 PyThreadState* __tstate = wxPyBeginAllowThreads();
42772 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42773 wxPyEndAllowThreads(__tstate);
42774 if (PyErr_Occurred()) SWIG_fail;
42775 }
42776 {
42777 resultobj = wxPyMake_wxObject(result, (bool)0);
42778 }
42779 {
42780 if (temp3)
42781 delete arg3;
42782 }
42783 {
42784 if (temp4)
42785 delete arg4;
42786 }
42787 return resultobj;
42788 fail:
42789 {
42790 if (temp3)
42791 delete arg3;
42792 }
42793 {
42794 if (temp4)
42795 delete arg4;
42796 }
42797 return NULL;
42798 }
42799
42800
42801 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42802 PyObject *resultobj = 0;
42803 wxMenu *arg1 = (wxMenu *) 0 ;
42804 wxMenuItem *result = 0 ;
42805 void *argp1 = 0 ;
42806 int res1 = 0 ;
42807 PyObject *swig_obj[1] ;
42808
42809 if (!args) SWIG_fail;
42810 swig_obj[0] = args;
42811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42812 if (!SWIG_IsOK(res1)) {
42813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42814 }
42815 arg1 = reinterpret_cast< wxMenu * >(argp1);
42816 {
42817 PyThreadState* __tstate = wxPyBeginAllowThreads();
42818 result = (wxMenuItem *)(arg1)->PrependSeparator();
42819 wxPyEndAllowThreads(__tstate);
42820 if (PyErr_Occurred()) SWIG_fail;
42821 }
42822 {
42823 resultobj = wxPyMake_wxObject(result, (bool)0);
42824 }
42825 return resultobj;
42826 fail:
42827 return NULL;
42828 }
42829
42830
42831 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42832 PyObject *resultobj = 0;
42833 wxMenu *arg1 = (wxMenu *) 0 ;
42834 int arg2 ;
42835 wxString *arg3 = 0 ;
42836 wxString const &arg4_defvalue = wxPyEmptyString ;
42837 wxString *arg4 = (wxString *) &arg4_defvalue ;
42838 wxMenuItem *result = 0 ;
42839 void *argp1 = 0 ;
42840 int res1 = 0 ;
42841 int val2 ;
42842 int ecode2 = 0 ;
42843 bool temp3 = false ;
42844 bool temp4 = false ;
42845 PyObject * obj0 = 0 ;
42846 PyObject * obj1 = 0 ;
42847 PyObject * obj2 = 0 ;
42848 PyObject * obj3 = 0 ;
42849 char * kwnames[] = {
42850 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42851 };
42852
42853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42855 if (!SWIG_IsOK(res1)) {
42856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42857 }
42858 arg1 = reinterpret_cast< wxMenu * >(argp1);
42859 ecode2 = SWIG_AsVal_int(obj1, &val2);
42860 if (!SWIG_IsOK(ecode2)) {
42861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42862 }
42863 arg2 = static_cast< int >(val2);
42864 {
42865 arg3 = wxString_in_helper(obj2);
42866 if (arg3 == NULL) SWIG_fail;
42867 temp3 = true;
42868 }
42869 if (obj3) {
42870 {
42871 arg4 = wxString_in_helper(obj3);
42872 if (arg4 == NULL) SWIG_fail;
42873 temp4 = true;
42874 }
42875 }
42876 {
42877 PyThreadState* __tstate = wxPyBeginAllowThreads();
42878 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42879 wxPyEndAllowThreads(__tstate);
42880 if (PyErr_Occurred()) SWIG_fail;
42881 }
42882 {
42883 resultobj = wxPyMake_wxObject(result, (bool)0);
42884 }
42885 {
42886 if (temp3)
42887 delete arg3;
42888 }
42889 {
42890 if (temp4)
42891 delete arg4;
42892 }
42893 return resultobj;
42894 fail:
42895 {
42896 if (temp3)
42897 delete arg3;
42898 }
42899 {
42900 if (temp4)
42901 delete arg4;
42902 }
42903 return NULL;
42904 }
42905
42906
42907 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42908 PyObject *resultobj = 0;
42909 wxMenu *arg1 = (wxMenu *) 0 ;
42910 int arg2 ;
42911 wxString *arg3 = 0 ;
42912 wxString const &arg4_defvalue = wxPyEmptyString ;
42913 wxString *arg4 = (wxString *) &arg4_defvalue ;
42914 wxMenuItem *result = 0 ;
42915 void *argp1 = 0 ;
42916 int res1 = 0 ;
42917 int val2 ;
42918 int ecode2 = 0 ;
42919 bool temp3 = false ;
42920 bool temp4 = false ;
42921 PyObject * obj0 = 0 ;
42922 PyObject * obj1 = 0 ;
42923 PyObject * obj2 = 0 ;
42924 PyObject * obj3 = 0 ;
42925 char * kwnames[] = {
42926 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42927 };
42928
42929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42931 if (!SWIG_IsOK(res1)) {
42932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42933 }
42934 arg1 = reinterpret_cast< wxMenu * >(argp1);
42935 ecode2 = SWIG_AsVal_int(obj1, &val2);
42936 if (!SWIG_IsOK(ecode2)) {
42937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42938 }
42939 arg2 = static_cast< int >(val2);
42940 {
42941 arg3 = wxString_in_helper(obj2);
42942 if (arg3 == NULL) SWIG_fail;
42943 temp3 = true;
42944 }
42945 if (obj3) {
42946 {
42947 arg4 = wxString_in_helper(obj3);
42948 if (arg4 == NULL) SWIG_fail;
42949 temp4 = true;
42950 }
42951 }
42952 {
42953 PyThreadState* __tstate = wxPyBeginAllowThreads();
42954 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42955 wxPyEndAllowThreads(__tstate);
42956 if (PyErr_Occurred()) SWIG_fail;
42957 }
42958 {
42959 resultobj = wxPyMake_wxObject(result, (bool)0);
42960 }
42961 {
42962 if (temp3)
42963 delete arg3;
42964 }
42965 {
42966 if (temp4)
42967 delete arg4;
42968 }
42969 return resultobj;
42970 fail:
42971 {
42972 if (temp3)
42973 delete arg3;
42974 }
42975 {
42976 if (temp4)
42977 delete arg4;
42978 }
42979 return NULL;
42980 }
42981
42982
42983 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42984 PyObject *resultobj = 0;
42985 wxMenu *arg1 = (wxMenu *) 0 ;
42986 int arg2 ;
42987 wxString *arg3 = 0 ;
42988 wxMenu *arg4 = (wxMenu *) 0 ;
42989 wxString const &arg5_defvalue = wxPyEmptyString ;
42990 wxString *arg5 = (wxString *) &arg5_defvalue ;
42991 wxMenuItem *result = 0 ;
42992 void *argp1 = 0 ;
42993 int res1 = 0 ;
42994 int val2 ;
42995 int ecode2 = 0 ;
42996 bool temp3 = false ;
42997 void *argp4 = 0 ;
42998 int res4 = 0 ;
42999 bool temp5 = false ;
43000 PyObject * obj0 = 0 ;
43001 PyObject * obj1 = 0 ;
43002 PyObject * obj2 = 0 ;
43003 PyObject * obj3 = 0 ;
43004 PyObject * obj4 = 0 ;
43005 char * kwnames[] = {
43006 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43007 };
43008
43009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43011 if (!SWIG_IsOK(res1)) {
43012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43013 }
43014 arg1 = reinterpret_cast< wxMenu * >(argp1);
43015 ecode2 = SWIG_AsVal_int(obj1, &val2);
43016 if (!SWIG_IsOK(ecode2)) {
43017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43018 }
43019 arg2 = static_cast< int >(val2);
43020 {
43021 arg3 = wxString_in_helper(obj2);
43022 if (arg3 == NULL) SWIG_fail;
43023 temp3 = true;
43024 }
43025 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43026 if (!SWIG_IsOK(res4)) {
43027 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43028 }
43029 arg4 = reinterpret_cast< wxMenu * >(argp4);
43030 if (obj4) {
43031 {
43032 arg5 = wxString_in_helper(obj4);
43033 if (arg5 == NULL) SWIG_fail;
43034 temp5 = true;
43035 }
43036 }
43037 {
43038 PyThreadState* __tstate = wxPyBeginAllowThreads();
43039 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 {
43044 resultobj = wxPyMake_wxObject(result, (bool)0);
43045 }
43046 {
43047 if (temp3)
43048 delete arg3;
43049 }
43050 {
43051 if (temp5)
43052 delete arg5;
43053 }
43054 return resultobj;
43055 fail:
43056 {
43057 if (temp3)
43058 delete arg3;
43059 }
43060 {
43061 if (temp5)
43062 delete arg5;
43063 }
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43069 PyObject *resultobj = 0;
43070 wxMenu *arg1 = (wxMenu *) 0 ;
43071 int arg2 ;
43072 wxMenuItem *result = 0 ;
43073 void *argp1 = 0 ;
43074 int res1 = 0 ;
43075 int val2 ;
43076 int ecode2 = 0 ;
43077 PyObject * obj0 = 0 ;
43078 PyObject * obj1 = 0 ;
43079 char * kwnames[] = {
43080 (char *) "self",(char *) "id", NULL
43081 };
43082
43083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43085 if (!SWIG_IsOK(res1)) {
43086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43087 }
43088 arg1 = reinterpret_cast< wxMenu * >(argp1);
43089 ecode2 = SWIG_AsVal_int(obj1, &val2);
43090 if (!SWIG_IsOK(ecode2)) {
43091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43092 }
43093 arg2 = static_cast< int >(val2);
43094 {
43095 PyThreadState* __tstate = wxPyBeginAllowThreads();
43096 result = (wxMenuItem *)(arg1)->Remove(arg2);
43097 wxPyEndAllowThreads(__tstate);
43098 if (PyErr_Occurred()) SWIG_fail;
43099 }
43100 {
43101 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43102 }
43103 return resultobj;
43104 fail:
43105 return NULL;
43106 }
43107
43108
43109 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43110 PyObject *resultobj = 0;
43111 wxMenu *arg1 = (wxMenu *) 0 ;
43112 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43113 wxMenuItem *result = 0 ;
43114 void *argp1 = 0 ;
43115 int res1 = 0 ;
43116 void *argp2 = 0 ;
43117 int res2 = 0 ;
43118 PyObject * obj0 = 0 ;
43119 PyObject * obj1 = 0 ;
43120 char * kwnames[] = {
43121 (char *) "self",(char *) "item", NULL
43122 };
43123
43124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43126 if (!SWIG_IsOK(res1)) {
43127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43128 }
43129 arg1 = reinterpret_cast< wxMenu * >(argp1);
43130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43131 if (!SWIG_IsOK(res2)) {
43132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43133 }
43134 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43135 {
43136 PyThreadState* __tstate = wxPyBeginAllowThreads();
43137 result = (wxMenuItem *)(arg1)->Remove(arg2);
43138 wxPyEndAllowThreads(__tstate);
43139 if (PyErr_Occurred()) SWIG_fail;
43140 }
43141 {
43142 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43143 }
43144 return resultobj;
43145 fail:
43146 return NULL;
43147 }
43148
43149
43150 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43151 PyObject *resultobj = 0;
43152 wxMenu *arg1 = (wxMenu *) 0 ;
43153 int arg2 ;
43154 bool result;
43155 void *argp1 = 0 ;
43156 int res1 = 0 ;
43157 int val2 ;
43158 int ecode2 = 0 ;
43159 PyObject * obj0 = 0 ;
43160 PyObject * obj1 = 0 ;
43161 char * kwnames[] = {
43162 (char *) "self",(char *) "id", NULL
43163 };
43164
43165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43167 if (!SWIG_IsOK(res1)) {
43168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43169 }
43170 arg1 = reinterpret_cast< wxMenu * >(argp1);
43171 ecode2 = SWIG_AsVal_int(obj1, &val2);
43172 if (!SWIG_IsOK(ecode2)) {
43173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43174 }
43175 arg2 = static_cast< int >(val2);
43176 {
43177 PyThreadState* __tstate = wxPyBeginAllowThreads();
43178 result = (bool)(arg1)->Delete(arg2);
43179 wxPyEndAllowThreads(__tstate);
43180 if (PyErr_Occurred()) SWIG_fail;
43181 }
43182 {
43183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43184 }
43185 return resultobj;
43186 fail:
43187 return NULL;
43188 }
43189
43190
43191 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43192 PyObject *resultobj = 0;
43193 wxMenu *arg1 = (wxMenu *) 0 ;
43194 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43195 bool result;
43196 void *argp1 = 0 ;
43197 int res1 = 0 ;
43198 void *argp2 = 0 ;
43199 int res2 = 0 ;
43200 PyObject * obj0 = 0 ;
43201 PyObject * obj1 = 0 ;
43202 char * kwnames[] = {
43203 (char *) "self",(char *) "item", NULL
43204 };
43205
43206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43208 if (!SWIG_IsOK(res1)) {
43209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43210 }
43211 arg1 = reinterpret_cast< wxMenu * >(argp1);
43212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43213 if (!SWIG_IsOK(res2)) {
43214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43215 }
43216 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43217 {
43218 PyThreadState* __tstate = wxPyBeginAllowThreads();
43219 result = (bool)(arg1)->Delete(arg2);
43220 wxPyEndAllowThreads(__tstate);
43221 if (PyErr_Occurred()) SWIG_fail;
43222 }
43223 {
43224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43225 }
43226 return resultobj;
43227 fail:
43228 return NULL;
43229 }
43230
43231
43232 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43233 PyObject *resultobj = 0;
43234 wxMenu *arg1 = (wxMenu *) 0 ;
43235 void *argp1 = 0 ;
43236 int res1 = 0 ;
43237 PyObject *swig_obj[1] ;
43238
43239 if (!args) SWIG_fail;
43240 swig_obj[0] = args;
43241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43242 if (!SWIG_IsOK(res1)) {
43243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43244 }
43245 arg1 = reinterpret_cast< wxMenu * >(argp1);
43246 {
43247 PyThreadState* __tstate = wxPyBeginAllowThreads();
43248 wxMenu_Destroy(arg1);
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 resultobj = SWIG_Py_Void();
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43260 PyObject *resultobj = 0;
43261 wxMenu *arg1 = (wxMenu *) 0 ;
43262 int arg2 ;
43263 bool result;
43264 void *argp1 = 0 ;
43265 int res1 = 0 ;
43266 int val2 ;
43267 int ecode2 = 0 ;
43268 PyObject * obj0 = 0 ;
43269 PyObject * obj1 = 0 ;
43270 char * kwnames[] = {
43271 (char *) "self",(char *) "id", NULL
43272 };
43273
43274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43276 if (!SWIG_IsOK(res1)) {
43277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43278 }
43279 arg1 = reinterpret_cast< wxMenu * >(argp1);
43280 ecode2 = SWIG_AsVal_int(obj1, &val2);
43281 if (!SWIG_IsOK(ecode2)) {
43282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43283 }
43284 arg2 = static_cast< int >(val2);
43285 {
43286 PyThreadState* __tstate = wxPyBeginAllowThreads();
43287 result = (bool)(arg1)->Destroy(arg2);
43288 wxPyEndAllowThreads(__tstate);
43289 if (PyErr_Occurred()) SWIG_fail;
43290 }
43291 {
43292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43293 }
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43301 PyObject *resultobj = 0;
43302 wxMenu *arg1 = (wxMenu *) 0 ;
43303 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43304 bool result;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 void *argp2 = 0 ;
43308 int res2 = 0 ;
43309 PyObject * obj0 = 0 ;
43310 PyObject * obj1 = 0 ;
43311 char * kwnames[] = {
43312 (char *) "self",(char *) "item", NULL
43313 };
43314
43315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43317 if (!SWIG_IsOK(res1)) {
43318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43319 }
43320 arg1 = reinterpret_cast< wxMenu * >(argp1);
43321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43322 if (!SWIG_IsOK(res2)) {
43323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43324 }
43325 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43326 {
43327 PyThreadState* __tstate = wxPyBeginAllowThreads();
43328 result = (bool)(arg1)->Destroy(arg2);
43329 wxPyEndAllowThreads(__tstate);
43330 if (PyErr_Occurred()) SWIG_fail;
43331 }
43332 {
43333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43334 }
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43342 PyObject *resultobj = 0;
43343 wxMenu *arg1 = (wxMenu *) 0 ;
43344 size_t result;
43345 void *argp1 = 0 ;
43346 int res1 = 0 ;
43347 PyObject *swig_obj[1] ;
43348
43349 if (!args) SWIG_fail;
43350 swig_obj[0] = args;
43351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43352 if (!SWIG_IsOK(res1)) {
43353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43354 }
43355 arg1 = reinterpret_cast< wxMenu * >(argp1);
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43359 wxPyEndAllowThreads(__tstate);
43360 if (PyErr_Occurred()) SWIG_fail;
43361 }
43362 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43363 return resultobj;
43364 fail:
43365 return NULL;
43366 }
43367
43368
43369 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43370 PyObject *resultobj = 0;
43371 wxMenu *arg1 = (wxMenu *) 0 ;
43372 PyObject *result = 0 ;
43373 void *argp1 = 0 ;
43374 int res1 = 0 ;
43375 PyObject *swig_obj[1] ;
43376
43377 if (!args) SWIG_fail;
43378 swig_obj[0] = args;
43379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43380 if (!SWIG_IsOK(res1)) {
43381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43382 }
43383 arg1 = reinterpret_cast< wxMenu * >(argp1);
43384 {
43385 PyThreadState* __tstate = wxPyBeginAllowThreads();
43386 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43387 wxPyEndAllowThreads(__tstate);
43388 if (PyErr_Occurred()) SWIG_fail;
43389 }
43390 resultobj = result;
43391 return resultobj;
43392 fail:
43393 return NULL;
43394 }
43395
43396
43397 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43398 PyObject *resultobj = 0;
43399 wxMenu *arg1 = (wxMenu *) 0 ;
43400 wxString *arg2 = 0 ;
43401 int result;
43402 void *argp1 = 0 ;
43403 int res1 = 0 ;
43404 bool temp2 = false ;
43405 PyObject * obj0 = 0 ;
43406 PyObject * obj1 = 0 ;
43407 char * kwnames[] = {
43408 (char *) "self",(char *) "item", NULL
43409 };
43410
43411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43413 if (!SWIG_IsOK(res1)) {
43414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43415 }
43416 arg1 = reinterpret_cast< wxMenu * >(argp1);
43417 {
43418 arg2 = wxString_in_helper(obj1);
43419 if (arg2 == NULL) SWIG_fail;
43420 temp2 = true;
43421 }
43422 {
43423 PyThreadState* __tstate = wxPyBeginAllowThreads();
43424 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43425 wxPyEndAllowThreads(__tstate);
43426 if (PyErr_Occurred()) SWIG_fail;
43427 }
43428 resultobj = SWIG_From_int(static_cast< int >(result));
43429 {
43430 if (temp2)
43431 delete arg2;
43432 }
43433 return resultobj;
43434 fail:
43435 {
43436 if (temp2)
43437 delete arg2;
43438 }
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_Menu_FindItemById(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_FindItemById",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_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
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_FindItemById" "', expected argument " "2"" of type '" "int""'");
43467 }
43468 arg2 = static_cast< int >(val2);
43469 {
43470 PyThreadState* __tstate = wxPyBeginAllowThreads();
43471 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 {
43476 resultobj = wxPyMake_wxObject(result, (bool)0);
43477 }
43478 return resultobj;
43479 fail:
43480 return NULL;
43481 }
43482
43483
43484 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43485 PyObject *resultobj = 0;
43486 wxMenu *arg1 = (wxMenu *) 0 ;
43487 size_t arg2 ;
43488 wxMenuItem *result = 0 ;
43489 void *argp1 = 0 ;
43490 int res1 = 0 ;
43491 size_t val2 ;
43492 int ecode2 = 0 ;
43493 PyObject * obj0 = 0 ;
43494 PyObject * obj1 = 0 ;
43495 char * kwnames[] = {
43496 (char *) "self",(char *) "position", NULL
43497 };
43498
43499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",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_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43503 }
43504 arg1 = reinterpret_cast< wxMenu * >(argp1);
43505 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43506 if (!SWIG_IsOK(ecode2)) {
43507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43508 }
43509 arg2 = static_cast< size_t >(val2);
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43513 wxPyEndAllowThreads(__tstate);
43514 if (PyErr_Occurred()) SWIG_fail;
43515 }
43516 {
43517 resultobj = wxPyMake_wxObject(result, (bool)0);
43518 }
43519 return resultobj;
43520 fail:
43521 return NULL;
43522 }
43523
43524
43525 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43526 PyObject *resultobj = 0;
43527 wxMenu *arg1 = (wxMenu *) 0 ;
43528 int arg2 ;
43529 bool arg3 ;
43530 void *argp1 = 0 ;
43531 int res1 = 0 ;
43532 int val2 ;
43533 int ecode2 = 0 ;
43534 bool val3 ;
43535 int ecode3 = 0 ;
43536 PyObject * obj0 = 0 ;
43537 PyObject * obj1 = 0 ;
43538 PyObject * obj2 = 0 ;
43539 char * kwnames[] = {
43540 (char *) "self",(char *) "id",(char *) "enable", NULL
43541 };
43542
43543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43545 if (!SWIG_IsOK(res1)) {
43546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43547 }
43548 arg1 = reinterpret_cast< wxMenu * >(argp1);
43549 ecode2 = SWIG_AsVal_int(obj1, &val2);
43550 if (!SWIG_IsOK(ecode2)) {
43551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43552 }
43553 arg2 = static_cast< int >(val2);
43554 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43555 if (!SWIG_IsOK(ecode3)) {
43556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43557 }
43558 arg3 = static_cast< bool >(val3);
43559 {
43560 PyThreadState* __tstate = wxPyBeginAllowThreads();
43561 (arg1)->Enable(arg2,arg3);
43562 wxPyEndAllowThreads(__tstate);
43563 if (PyErr_Occurred()) SWIG_fail;
43564 }
43565 resultobj = SWIG_Py_Void();
43566 return resultobj;
43567 fail:
43568 return NULL;
43569 }
43570
43571
43572 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43573 PyObject *resultobj = 0;
43574 wxMenu *arg1 = (wxMenu *) 0 ;
43575 int arg2 ;
43576 bool result;
43577 void *argp1 = 0 ;
43578 int res1 = 0 ;
43579 int val2 ;
43580 int ecode2 = 0 ;
43581 PyObject * obj0 = 0 ;
43582 PyObject * obj1 = 0 ;
43583 char * kwnames[] = {
43584 (char *) "self",(char *) "id", NULL
43585 };
43586
43587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43589 if (!SWIG_IsOK(res1)) {
43590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43591 }
43592 arg1 = reinterpret_cast< wxMenu * >(argp1);
43593 ecode2 = SWIG_AsVal_int(obj1, &val2);
43594 if (!SWIG_IsOK(ecode2)) {
43595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43596 }
43597 arg2 = static_cast< int >(val2);
43598 {
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 {
43605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43606 }
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43614 PyObject *resultobj = 0;
43615 wxMenu *arg1 = (wxMenu *) 0 ;
43616 int arg2 ;
43617 bool arg3 ;
43618 void *argp1 = 0 ;
43619 int res1 = 0 ;
43620 int val2 ;
43621 int ecode2 = 0 ;
43622 bool val3 ;
43623 int ecode3 = 0 ;
43624 PyObject * obj0 = 0 ;
43625 PyObject * obj1 = 0 ;
43626 PyObject * obj2 = 0 ;
43627 char * kwnames[] = {
43628 (char *) "self",(char *) "id",(char *) "check", NULL
43629 };
43630
43631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43633 if (!SWIG_IsOK(res1)) {
43634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43635 }
43636 arg1 = reinterpret_cast< wxMenu * >(argp1);
43637 ecode2 = SWIG_AsVal_int(obj1, &val2);
43638 if (!SWIG_IsOK(ecode2)) {
43639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43640 }
43641 arg2 = static_cast< int >(val2);
43642 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43643 if (!SWIG_IsOK(ecode3)) {
43644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43645 }
43646 arg3 = static_cast< bool >(val3);
43647 {
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 (arg1)->Check(arg2,arg3);
43650 wxPyEndAllowThreads(__tstate);
43651 if (PyErr_Occurred()) SWIG_fail;
43652 }
43653 resultobj = SWIG_Py_Void();
43654 return resultobj;
43655 fail:
43656 return NULL;
43657 }
43658
43659
43660 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43661 PyObject *resultobj = 0;
43662 wxMenu *arg1 = (wxMenu *) 0 ;
43663 int arg2 ;
43664 bool result;
43665 void *argp1 = 0 ;
43666 int res1 = 0 ;
43667 int val2 ;
43668 int ecode2 = 0 ;
43669 PyObject * obj0 = 0 ;
43670 PyObject * obj1 = 0 ;
43671 char * kwnames[] = {
43672 (char *) "self",(char *) "id", NULL
43673 };
43674
43675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43677 if (!SWIG_IsOK(res1)) {
43678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43679 }
43680 arg1 = reinterpret_cast< wxMenu * >(argp1);
43681 ecode2 = SWIG_AsVal_int(obj1, &val2);
43682 if (!SWIG_IsOK(ecode2)) {
43683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43684 }
43685 arg2 = static_cast< int >(val2);
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43694 }
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43702 PyObject *resultobj = 0;
43703 wxMenu *arg1 = (wxMenu *) 0 ;
43704 int arg2 ;
43705 wxString *arg3 = 0 ;
43706 void *argp1 = 0 ;
43707 int res1 = 0 ;
43708 int val2 ;
43709 int ecode2 = 0 ;
43710 bool temp3 = false ;
43711 PyObject * obj0 = 0 ;
43712 PyObject * obj1 = 0 ;
43713 PyObject * obj2 = 0 ;
43714 char * kwnames[] = {
43715 (char *) "self",(char *) "id",(char *) "label", NULL
43716 };
43717
43718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43720 if (!SWIG_IsOK(res1)) {
43721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43722 }
43723 arg1 = reinterpret_cast< wxMenu * >(argp1);
43724 ecode2 = SWIG_AsVal_int(obj1, &val2);
43725 if (!SWIG_IsOK(ecode2)) {
43726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43727 }
43728 arg2 = static_cast< int >(val2);
43729 {
43730 arg3 = wxString_in_helper(obj2);
43731 if (arg3 == NULL) SWIG_fail;
43732 temp3 = true;
43733 }
43734 {
43735 PyThreadState* __tstate = wxPyBeginAllowThreads();
43736 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43737 wxPyEndAllowThreads(__tstate);
43738 if (PyErr_Occurred()) SWIG_fail;
43739 }
43740 resultobj = SWIG_Py_Void();
43741 {
43742 if (temp3)
43743 delete arg3;
43744 }
43745 return resultobj;
43746 fail:
43747 {
43748 if (temp3)
43749 delete arg3;
43750 }
43751 return NULL;
43752 }
43753
43754
43755 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43756 PyObject *resultobj = 0;
43757 wxMenu *arg1 = (wxMenu *) 0 ;
43758 int arg2 ;
43759 wxString result;
43760 void *argp1 = 0 ;
43761 int res1 = 0 ;
43762 int val2 ;
43763 int ecode2 = 0 ;
43764 PyObject * obj0 = 0 ;
43765 PyObject * obj1 = 0 ;
43766 char * kwnames[] = {
43767 (char *) "self",(char *) "id", NULL
43768 };
43769
43770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43772 if (!SWIG_IsOK(res1)) {
43773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43774 }
43775 arg1 = reinterpret_cast< wxMenu * >(argp1);
43776 ecode2 = SWIG_AsVal_int(obj1, &val2);
43777 if (!SWIG_IsOK(ecode2)) {
43778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43779 }
43780 arg2 = static_cast< int >(val2);
43781 {
43782 PyThreadState* __tstate = wxPyBeginAllowThreads();
43783 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43784 wxPyEndAllowThreads(__tstate);
43785 if (PyErr_Occurred()) SWIG_fail;
43786 }
43787 {
43788 #if wxUSE_UNICODE
43789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43790 #else
43791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43792 #endif
43793 }
43794 return resultobj;
43795 fail:
43796 return NULL;
43797 }
43798
43799
43800 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43801 PyObject *resultobj = 0;
43802 wxMenu *arg1 = (wxMenu *) 0 ;
43803 int arg2 ;
43804 wxString *arg3 = 0 ;
43805 void *argp1 = 0 ;
43806 int res1 = 0 ;
43807 int val2 ;
43808 int ecode2 = 0 ;
43809 bool temp3 = false ;
43810 PyObject * obj0 = 0 ;
43811 PyObject * obj1 = 0 ;
43812 PyObject * obj2 = 0 ;
43813 char * kwnames[] = {
43814 (char *) "self",(char *) "id",(char *) "helpString", NULL
43815 };
43816
43817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43819 if (!SWIG_IsOK(res1)) {
43820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43821 }
43822 arg1 = reinterpret_cast< wxMenu * >(argp1);
43823 ecode2 = SWIG_AsVal_int(obj1, &val2);
43824 if (!SWIG_IsOK(ecode2)) {
43825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43826 }
43827 arg2 = static_cast< int >(val2);
43828 {
43829 arg3 = wxString_in_helper(obj2);
43830 if (arg3 == NULL) SWIG_fail;
43831 temp3 = true;
43832 }
43833 {
43834 PyThreadState* __tstate = wxPyBeginAllowThreads();
43835 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43836 wxPyEndAllowThreads(__tstate);
43837 if (PyErr_Occurred()) SWIG_fail;
43838 }
43839 resultobj = SWIG_Py_Void();
43840 {
43841 if (temp3)
43842 delete arg3;
43843 }
43844 return resultobj;
43845 fail:
43846 {
43847 if (temp3)
43848 delete arg3;
43849 }
43850 return NULL;
43851 }
43852
43853
43854 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43855 PyObject *resultobj = 0;
43856 wxMenu *arg1 = (wxMenu *) 0 ;
43857 int arg2 ;
43858 wxString result;
43859 void *argp1 = 0 ;
43860 int res1 = 0 ;
43861 int val2 ;
43862 int ecode2 = 0 ;
43863 PyObject * obj0 = 0 ;
43864 PyObject * obj1 = 0 ;
43865 char * kwnames[] = {
43866 (char *) "self",(char *) "id", NULL
43867 };
43868
43869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43871 if (!SWIG_IsOK(res1)) {
43872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43873 }
43874 arg1 = reinterpret_cast< wxMenu * >(argp1);
43875 ecode2 = SWIG_AsVal_int(obj1, &val2);
43876 if (!SWIG_IsOK(ecode2)) {
43877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43878 }
43879 arg2 = static_cast< int >(val2);
43880 {
43881 PyThreadState* __tstate = wxPyBeginAllowThreads();
43882 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43883 wxPyEndAllowThreads(__tstate);
43884 if (PyErr_Occurred()) SWIG_fail;
43885 }
43886 {
43887 #if wxUSE_UNICODE
43888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43889 #else
43890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43891 #endif
43892 }
43893 return resultobj;
43894 fail:
43895 return NULL;
43896 }
43897
43898
43899 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43900 PyObject *resultobj = 0;
43901 wxMenu *arg1 = (wxMenu *) 0 ;
43902 wxString *arg2 = 0 ;
43903 void *argp1 = 0 ;
43904 int res1 = 0 ;
43905 bool temp2 = false ;
43906 PyObject * obj0 = 0 ;
43907 PyObject * obj1 = 0 ;
43908 char * kwnames[] = {
43909 (char *) "self",(char *) "title", NULL
43910 };
43911
43912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43914 if (!SWIG_IsOK(res1)) {
43915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43916 }
43917 arg1 = reinterpret_cast< wxMenu * >(argp1);
43918 {
43919 arg2 = wxString_in_helper(obj1);
43920 if (arg2 == NULL) SWIG_fail;
43921 temp2 = true;
43922 }
43923 {
43924 PyThreadState* __tstate = wxPyBeginAllowThreads();
43925 (arg1)->SetTitle((wxString const &)*arg2);
43926 wxPyEndAllowThreads(__tstate);
43927 if (PyErr_Occurred()) SWIG_fail;
43928 }
43929 resultobj = SWIG_Py_Void();
43930 {
43931 if (temp2)
43932 delete arg2;
43933 }
43934 return resultobj;
43935 fail:
43936 {
43937 if (temp2)
43938 delete arg2;
43939 }
43940 return NULL;
43941 }
43942
43943
43944 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43945 PyObject *resultobj = 0;
43946 wxMenu *arg1 = (wxMenu *) 0 ;
43947 wxString result;
43948 void *argp1 = 0 ;
43949 int res1 = 0 ;
43950 PyObject *swig_obj[1] ;
43951
43952 if (!args) SWIG_fail;
43953 swig_obj[0] = args;
43954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43955 if (!SWIG_IsOK(res1)) {
43956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43957 }
43958 arg1 = reinterpret_cast< wxMenu * >(argp1);
43959 {
43960 PyThreadState* __tstate = wxPyBeginAllowThreads();
43961 result = ((wxMenu const *)arg1)->GetTitle();
43962 wxPyEndAllowThreads(__tstate);
43963 if (PyErr_Occurred()) SWIG_fail;
43964 }
43965 {
43966 #if wxUSE_UNICODE
43967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43968 #else
43969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43970 #endif
43971 }
43972 return resultobj;
43973 fail:
43974 return NULL;
43975 }
43976
43977
43978 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43979 PyObject *resultobj = 0;
43980 wxMenu *arg1 = (wxMenu *) 0 ;
43981 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43982 void *argp1 = 0 ;
43983 int res1 = 0 ;
43984 void *argp2 = 0 ;
43985 int res2 = 0 ;
43986 PyObject * obj0 = 0 ;
43987 PyObject * obj1 = 0 ;
43988 char * kwnames[] = {
43989 (char *) "self",(char *) "handler", NULL
43990 };
43991
43992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43994 if (!SWIG_IsOK(res1)) {
43995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43996 }
43997 arg1 = reinterpret_cast< wxMenu * >(argp1);
43998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43999 if (!SWIG_IsOK(res2)) {
44000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44001 }
44002 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44003 {
44004 PyThreadState* __tstate = wxPyBeginAllowThreads();
44005 (arg1)->SetEventHandler(arg2);
44006 wxPyEndAllowThreads(__tstate);
44007 if (PyErr_Occurred()) SWIG_fail;
44008 }
44009 resultobj = SWIG_Py_Void();
44010 return resultobj;
44011 fail:
44012 return NULL;
44013 }
44014
44015
44016 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44017 PyObject *resultobj = 0;
44018 wxMenu *arg1 = (wxMenu *) 0 ;
44019 wxEvtHandler *result = 0 ;
44020 void *argp1 = 0 ;
44021 int res1 = 0 ;
44022 PyObject *swig_obj[1] ;
44023
44024 if (!args) SWIG_fail;
44025 swig_obj[0] = args;
44026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44027 if (!SWIG_IsOK(res1)) {
44028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44029 }
44030 arg1 = reinterpret_cast< wxMenu * >(argp1);
44031 {
44032 PyThreadState* __tstate = wxPyBeginAllowThreads();
44033 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44034 wxPyEndAllowThreads(__tstate);
44035 if (PyErr_Occurred()) SWIG_fail;
44036 }
44037 {
44038 resultobj = wxPyMake_wxObject(result, 0);
44039 }
44040 return resultobj;
44041 fail:
44042 return NULL;
44043 }
44044
44045
44046 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44047 PyObject *resultobj = 0;
44048 wxMenu *arg1 = (wxMenu *) 0 ;
44049 wxWindow *arg2 = (wxWindow *) 0 ;
44050 void *argp1 = 0 ;
44051 int res1 = 0 ;
44052 void *argp2 = 0 ;
44053 int res2 = 0 ;
44054 PyObject * obj0 = 0 ;
44055 PyObject * obj1 = 0 ;
44056 char * kwnames[] = {
44057 (char *) "self",(char *) "win", NULL
44058 };
44059
44060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44062 if (!SWIG_IsOK(res1)) {
44063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44064 }
44065 arg1 = reinterpret_cast< wxMenu * >(argp1);
44066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44067 if (!SWIG_IsOK(res2)) {
44068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44069 }
44070 arg2 = reinterpret_cast< wxWindow * >(argp2);
44071 {
44072 PyThreadState* __tstate = wxPyBeginAllowThreads();
44073 (arg1)->SetInvokingWindow(arg2);
44074 wxPyEndAllowThreads(__tstate);
44075 if (PyErr_Occurred()) SWIG_fail;
44076 }
44077 resultobj = SWIG_Py_Void();
44078 return resultobj;
44079 fail:
44080 return NULL;
44081 }
44082
44083
44084 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44085 PyObject *resultobj = 0;
44086 wxMenu *arg1 = (wxMenu *) 0 ;
44087 wxWindow *result = 0 ;
44088 void *argp1 = 0 ;
44089 int res1 = 0 ;
44090 PyObject *swig_obj[1] ;
44091
44092 if (!args) SWIG_fail;
44093 swig_obj[0] = args;
44094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44095 if (!SWIG_IsOK(res1)) {
44096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44097 }
44098 arg1 = reinterpret_cast< wxMenu * >(argp1);
44099 {
44100 PyThreadState* __tstate = wxPyBeginAllowThreads();
44101 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44102 wxPyEndAllowThreads(__tstate);
44103 if (PyErr_Occurred()) SWIG_fail;
44104 }
44105 {
44106 resultobj = wxPyMake_wxObject(result, 0);
44107 }
44108 return resultobj;
44109 fail:
44110 return NULL;
44111 }
44112
44113
44114 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44115 PyObject *resultobj = 0;
44116 wxMenu *arg1 = (wxMenu *) 0 ;
44117 long result;
44118 void *argp1 = 0 ;
44119 int res1 = 0 ;
44120 PyObject *swig_obj[1] ;
44121
44122 if (!args) SWIG_fail;
44123 swig_obj[0] = args;
44124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44125 if (!SWIG_IsOK(res1)) {
44126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44127 }
44128 arg1 = reinterpret_cast< wxMenu * >(argp1);
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 result = (long)((wxMenu const *)arg1)->GetStyle();
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 resultobj = SWIG_From_long(static_cast< long >(result));
44136 return resultobj;
44137 fail:
44138 return NULL;
44139 }
44140
44141
44142 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44143 PyObject *resultobj = 0;
44144 wxMenu *arg1 = (wxMenu *) 0 ;
44145 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44146 void *argp1 = 0 ;
44147 int res1 = 0 ;
44148 void *argp2 = 0 ;
44149 int res2 = 0 ;
44150 PyObject * obj0 = 0 ;
44151 PyObject * obj1 = 0 ;
44152 char * kwnames[] = {
44153 (char *) "self",(char *) "source", NULL
44154 };
44155
44156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44158 if (!SWIG_IsOK(res1)) {
44159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44160 }
44161 arg1 = reinterpret_cast< wxMenu * >(argp1);
44162 if (obj1) {
44163 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44164 if (!SWIG_IsOK(res2)) {
44165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44166 }
44167 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44168 }
44169 {
44170 PyThreadState* __tstate = wxPyBeginAllowThreads();
44171 (arg1)->UpdateUI(arg2);
44172 wxPyEndAllowThreads(__tstate);
44173 if (PyErr_Occurred()) SWIG_fail;
44174 }
44175 resultobj = SWIG_Py_Void();
44176 return resultobj;
44177 fail:
44178 return NULL;
44179 }
44180
44181
44182 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44183 PyObject *resultobj = 0;
44184 wxMenu *arg1 = (wxMenu *) 0 ;
44185 wxMenuBar *result = 0 ;
44186 void *argp1 = 0 ;
44187 int res1 = 0 ;
44188 PyObject *swig_obj[1] ;
44189
44190 if (!args) SWIG_fail;
44191 swig_obj[0] = args;
44192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44193 if (!SWIG_IsOK(res1)) {
44194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44195 }
44196 arg1 = reinterpret_cast< wxMenu * >(argp1);
44197 {
44198 PyThreadState* __tstate = wxPyBeginAllowThreads();
44199 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44200 wxPyEndAllowThreads(__tstate);
44201 if (PyErr_Occurred()) SWIG_fail;
44202 }
44203 {
44204 resultobj = wxPyMake_wxObject(result, (bool)0);
44205 }
44206 return resultobj;
44207 fail:
44208 return NULL;
44209 }
44210
44211
44212 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44213 PyObject *resultobj = 0;
44214 wxMenu *arg1 = (wxMenu *) 0 ;
44215 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44216 void *argp1 = 0 ;
44217 int res1 = 0 ;
44218 void *argp2 = 0 ;
44219 int res2 = 0 ;
44220 PyObject * obj0 = 0 ;
44221 PyObject * obj1 = 0 ;
44222 char * kwnames[] = {
44223 (char *) "self",(char *) "menubar", NULL
44224 };
44225
44226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44228 if (!SWIG_IsOK(res1)) {
44229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44230 }
44231 arg1 = reinterpret_cast< wxMenu * >(argp1);
44232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44233 if (!SWIG_IsOK(res2)) {
44234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44235 }
44236 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44237 {
44238 PyThreadState* __tstate = wxPyBeginAllowThreads();
44239 (arg1)->Attach(arg2);
44240 wxPyEndAllowThreads(__tstate);
44241 if (PyErr_Occurred()) SWIG_fail;
44242 }
44243 resultobj = SWIG_Py_Void();
44244 return resultobj;
44245 fail:
44246 return NULL;
44247 }
44248
44249
44250 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44251 PyObject *resultobj = 0;
44252 wxMenu *arg1 = (wxMenu *) 0 ;
44253 void *argp1 = 0 ;
44254 int res1 = 0 ;
44255 PyObject *swig_obj[1] ;
44256
44257 if (!args) SWIG_fail;
44258 swig_obj[0] = args;
44259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44260 if (!SWIG_IsOK(res1)) {
44261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44262 }
44263 arg1 = reinterpret_cast< wxMenu * >(argp1);
44264 {
44265 PyThreadState* __tstate = wxPyBeginAllowThreads();
44266 (arg1)->Detach();
44267 wxPyEndAllowThreads(__tstate);
44268 if (PyErr_Occurred()) SWIG_fail;
44269 }
44270 resultobj = SWIG_Py_Void();
44271 return resultobj;
44272 fail:
44273 return NULL;
44274 }
44275
44276
44277 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44278 PyObject *resultobj = 0;
44279 wxMenu *arg1 = (wxMenu *) 0 ;
44280 bool result;
44281 void *argp1 = 0 ;
44282 int res1 = 0 ;
44283 PyObject *swig_obj[1] ;
44284
44285 if (!args) SWIG_fail;
44286 swig_obj[0] = args;
44287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44288 if (!SWIG_IsOK(res1)) {
44289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44290 }
44291 arg1 = reinterpret_cast< wxMenu * >(argp1);
44292 {
44293 PyThreadState* __tstate = wxPyBeginAllowThreads();
44294 result = (bool)((wxMenu const *)arg1)->IsAttached();
44295 wxPyEndAllowThreads(__tstate);
44296 if (PyErr_Occurred()) SWIG_fail;
44297 }
44298 {
44299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44300 }
44301 return resultobj;
44302 fail:
44303 return NULL;
44304 }
44305
44306
44307 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44308 PyObject *resultobj = 0;
44309 wxMenu *arg1 = (wxMenu *) 0 ;
44310 wxMenu *arg2 = (wxMenu *) 0 ;
44311 void *argp1 = 0 ;
44312 int res1 = 0 ;
44313 void *argp2 = 0 ;
44314 int res2 = 0 ;
44315 PyObject * obj0 = 0 ;
44316 PyObject * obj1 = 0 ;
44317 char * kwnames[] = {
44318 (char *) "self",(char *) "parent", NULL
44319 };
44320
44321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44323 if (!SWIG_IsOK(res1)) {
44324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44325 }
44326 arg1 = reinterpret_cast< wxMenu * >(argp1);
44327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44328 if (!SWIG_IsOK(res2)) {
44329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44330 }
44331 arg2 = reinterpret_cast< wxMenu * >(argp2);
44332 {
44333 PyThreadState* __tstate = wxPyBeginAllowThreads();
44334 (arg1)->SetParent(arg2);
44335 wxPyEndAllowThreads(__tstate);
44336 if (PyErr_Occurred()) SWIG_fail;
44337 }
44338 resultobj = SWIG_Py_Void();
44339 return resultobj;
44340 fail:
44341 return NULL;
44342 }
44343
44344
44345 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44346 PyObject *resultobj = 0;
44347 wxMenu *arg1 = (wxMenu *) 0 ;
44348 wxMenu *result = 0 ;
44349 void *argp1 = 0 ;
44350 int res1 = 0 ;
44351 PyObject *swig_obj[1] ;
44352
44353 if (!args) SWIG_fail;
44354 swig_obj[0] = args;
44355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44356 if (!SWIG_IsOK(res1)) {
44357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44358 }
44359 arg1 = reinterpret_cast< wxMenu * >(argp1);
44360 {
44361 PyThreadState* __tstate = wxPyBeginAllowThreads();
44362 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44363 wxPyEndAllowThreads(__tstate);
44364 if (PyErr_Occurred()) SWIG_fail;
44365 }
44366 {
44367 resultobj = wxPyMake_wxObject(result, 0);
44368 }
44369 return resultobj;
44370 fail:
44371 return NULL;
44372 }
44373
44374
44375 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44376 PyObject *obj;
44377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44378 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44379 return SWIG_Py_Void();
44380 }
44381
44382 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44383 return SWIG_Python_InitShadowInstance(args);
44384 }
44385
44386 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44387 PyObject *resultobj = 0;
44388 long arg1 = (long) 0 ;
44389 wxMenuBar *result = 0 ;
44390 long val1 ;
44391 int ecode1 = 0 ;
44392 PyObject * obj0 = 0 ;
44393 char * kwnames[] = {
44394 (char *) "style", NULL
44395 };
44396
44397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44398 if (obj0) {
44399 ecode1 = SWIG_AsVal_long(obj0, &val1);
44400 if (!SWIG_IsOK(ecode1)) {
44401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44402 }
44403 arg1 = static_cast< long >(val1);
44404 }
44405 {
44406 if (!wxPyCheckForApp()) SWIG_fail;
44407 PyThreadState* __tstate = wxPyBeginAllowThreads();
44408 result = (wxMenuBar *)new wxMenuBar(arg1);
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44413 return resultobj;
44414 fail:
44415 return NULL;
44416 }
44417
44418
44419 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44420 PyObject *resultobj = 0;
44421 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44422 wxMenu *arg2 = (wxMenu *) 0 ;
44423 wxString *arg3 = 0 ;
44424 bool result;
44425 void *argp1 = 0 ;
44426 int res1 = 0 ;
44427 void *argp2 = 0 ;
44428 int res2 = 0 ;
44429 bool temp3 = false ;
44430 PyObject * obj0 = 0 ;
44431 PyObject * obj1 = 0 ;
44432 PyObject * obj2 = 0 ;
44433 char * kwnames[] = {
44434 (char *) "self",(char *) "menu",(char *) "title", NULL
44435 };
44436
44437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44439 if (!SWIG_IsOK(res1)) {
44440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44441 }
44442 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44444 if (!SWIG_IsOK(res2)) {
44445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44446 }
44447 arg2 = reinterpret_cast< wxMenu * >(argp2);
44448 {
44449 arg3 = wxString_in_helper(obj2);
44450 if (arg3 == NULL) SWIG_fail;
44451 temp3 = true;
44452 }
44453 {
44454 PyThreadState* __tstate = wxPyBeginAllowThreads();
44455 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44456 wxPyEndAllowThreads(__tstate);
44457 if (PyErr_Occurred()) SWIG_fail;
44458 }
44459 {
44460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44461 }
44462 {
44463 if (temp3)
44464 delete arg3;
44465 }
44466 return resultobj;
44467 fail:
44468 {
44469 if (temp3)
44470 delete arg3;
44471 }
44472 return NULL;
44473 }
44474
44475
44476 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44477 PyObject *resultobj = 0;
44478 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44479 size_t arg2 ;
44480 wxMenu *arg3 = (wxMenu *) 0 ;
44481 wxString *arg4 = 0 ;
44482 bool result;
44483 void *argp1 = 0 ;
44484 int res1 = 0 ;
44485 size_t val2 ;
44486 int ecode2 = 0 ;
44487 void *argp3 = 0 ;
44488 int res3 = 0 ;
44489 bool temp4 = false ;
44490 PyObject * obj0 = 0 ;
44491 PyObject * obj1 = 0 ;
44492 PyObject * obj2 = 0 ;
44493 PyObject * obj3 = 0 ;
44494 char * kwnames[] = {
44495 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44496 };
44497
44498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44500 if (!SWIG_IsOK(res1)) {
44501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44502 }
44503 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44504 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44505 if (!SWIG_IsOK(ecode2)) {
44506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44507 }
44508 arg2 = static_cast< size_t >(val2);
44509 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44510 if (!SWIG_IsOK(res3)) {
44511 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44512 }
44513 arg3 = reinterpret_cast< wxMenu * >(argp3);
44514 {
44515 arg4 = wxString_in_helper(obj3);
44516 if (arg4 == NULL) SWIG_fail;
44517 temp4 = true;
44518 }
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44522 wxPyEndAllowThreads(__tstate);
44523 if (PyErr_Occurred()) SWIG_fail;
44524 }
44525 {
44526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44527 }
44528 {
44529 if (temp4)
44530 delete arg4;
44531 }
44532 return resultobj;
44533 fail:
44534 {
44535 if (temp4)
44536 delete arg4;
44537 }
44538 return NULL;
44539 }
44540
44541
44542 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44543 PyObject *resultobj = 0;
44544 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44545 size_t result;
44546 void *argp1 = 0 ;
44547 int res1 = 0 ;
44548 PyObject *swig_obj[1] ;
44549
44550 if (!args) SWIG_fail;
44551 swig_obj[0] = args;
44552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44553 if (!SWIG_IsOK(res1)) {
44554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44555 }
44556 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44557 {
44558 PyThreadState* __tstate = wxPyBeginAllowThreads();
44559 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44560 wxPyEndAllowThreads(__tstate);
44561 if (PyErr_Occurred()) SWIG_fail;
44562 }
44563 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44564 return resultobj;
44565 fail:
44566 return NULL;
44567 }
44568
44569
44570 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44571 PyObject *resultobj = 0;
44572 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44573 size_t arg2 ;
44574 wxMenu *result = 0 ;
44575 void *argp1 = 0 ;
44576 int res1 = 0 ;
44577 size_t val2 ;
44578 int ecode2 = 0 ;
44579 PyObject * obj0 = 0 ;
44580 PyObject * obj1 = 0 ;
44581 char * kwnames[] = {
44582 (char *) "self",(char *) "pos", NULL
44583 };
44584
44585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44587 if (!SWIG_IsOK(res1)) {
44588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44589 }
44590 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44591 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44592 if (!SWIG_IsOK(ecode2)) {
44593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44594 }
44595 arg2 = static_cast< size_t >(val2);
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44599 wxPyEndAllowThreads(__tstate);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 }
44602 {
44603 resultobj = wxPyMake_wxObject(result, 0);
44604 }
44605 return resultobj;
44606 fail:
44607 return NULL;
44608 }
44609
44610
44611 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44612 PyObject *resultobj = 0;
44613 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44614 size_t arg2 ;
44615 wxMenu *arg3 = (wxMenu *) 0 ;
44616 wxString *arg4 = 0 ;
44617 wxMenu *result = 0 ;
44618 void *argp1 = 0 ;
44619 int res1 = 0 ;
44620 size_t val2 ;
44621 int ecode2 = 0 ;
44622 void *argp3 = 0 ;
44623 int res3 = 0 ;
44624 bool temp4 = false ;
44625 PyObject * obj0 = 0 ;
44626 PyObject * obj1 = 0 ;
44627 PyObject * obj2 = 0 ;
44628 PyObject * obj3 = 0 ;
44629 char * kwnames[] = {
44630 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44631 };
44632
44633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44635 if (!SWIG_IsOK(res1)) {
44636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44637 }
44638 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44639 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44640 if (!SWIG_IsOK(ecode2)) {
44641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44642 }
44643 arg2 = static_cast< size_t >(val2);
44644 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44645 if (!SWIG_IsOK(res3)) {
44646 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44647 }
44648 arg3 = reinterpret_cast< wxMenu * >(argp3);
44649 {
44650 arg4 = wxString_in_helper(obj3);
44651 if (arg4 == NULL) SWIG_fail;
44652 temp4 = true;
44653 }
44654 {
44655 PyThreadState* __tstate = wxPyBeginAllowThreads();
44656 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44657 wxPyEndAllowThreads(__tstate);
44658 if (PyErr_Occurred()) SWIG_fail;
44659 }
44660 {
44661 resultobj = wxPyMake_wxObject(result, 0);
44662 }
44663 {
44664 if (temp4)
44665 delete arg4;
44666 }
44667 return resultobj;
44668 fail:
44669 {
44670 if (temp4)
44671 delete arg4;
44672 }
44673 return NULL;
44674 }
44675
44676
44677 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44678 PyObject *resultobj = 0;
44679 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44680 size_t arg2 ;
44681 wxMenu *result = 0 ;
44682 void *argp1 = 0 ;
44683 int res1 = 0 ;
44684 size_t val2 ;
44685 int ecode2 = 0 ;
44686 PyObject * obj0 = 0 ;
44687 PyObject * obj1 = 0 ;
44688 char * kwnames[] = {
44689 (char *) "self",(char *) "pos", NULL
44690 };
44691
44692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44694 if (!SWIG_IsOK(res1)) {
44695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44696 }
44697 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44698 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44699 if (!SWIG_IsOK(ecode2)) {
44700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44701 }
44702 arg2 = static_cast< size_t >(val2);
44703 {
44704 PyThreadState* __tstate = wxPyBeginAllowThreads();
44705 result = (wxMenu *)(arg1)->Remove(arg2);
44706 wxPyEndAllowThreads(__tstate);
44707 if (PyErr_Occurred()) SWIG_fail;
44708 }
44709 {
44710 resultobj = wxPyMake_wxObject(result, 0);
44711 }
44712 return resultobj;
44713 fail:
44714 return NULL;
44715 }
44716
44717
44718 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44719 PyObject *resultobj = 0;
44720 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44721 size_t arg2 ;
44722 bool arg3 ;
44723 void *argp1 = 0 ;
44724 int res1 = 0 ;
44725 size_t val2 ;
44726 int ecode2 = 0 ;
44727 bool val3 ;
44728 int ecode3 = 0 ;
44729 PyObject * obj0 = 0 ;
44730 PyObject * obj1 = 0 ;
44731 PyObject * obj2 = 0 ;
44732 char * kwnames[] = {
44733 (char *) "self",(char *) "pos",(char *) "enable", NULL
44734 };
44735
44736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44738 if (!SWIG_IsOK(res1)) {
44739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44740 }
44741 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44742 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44743 if (!SWIG_IsOK(ecode2)) {
44744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44745 }
44746 arg2 = static_cast< size_t >(val2);
44747 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44748 if (!SWIG_IsOK(ecode3)) {
44749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44750 }
44751 arg3 = static_cast< bool >(val3);
44752 {
44753 PyThreadState* __tstate = wxPyBeginAllowThreads();
44754 (arg1)->EnableTop(arg2,arg3);
44755 wxPyEndAllowThreads(__tstate);
44756 if (PyErr_Occurred()) SWIG_fail;
44757 }
44758 resultobj = SWIG_Py_Void();
44759 return resultobj;
44760 fail:
44761 return NULL;
44762 }
44763
44764
44765 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44766 PyObject *resultobj = 0;
44767 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44768 size_t arg2 ;
44769 bool result;
44770 void *argp1 = 0 ;
44771 int res1 = 0 ;
44772 size_t val2 ;
44773 int ecode2 = 0 ;
44774 PyObject * obj0 = 0 ;
44775 PyObject * obj1 = 0 ;
44776 char * kwnames[] = {
44777 (char *) "self",(char *) "pos", NULL
44778 };
44779
44780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44782 if (!SWIG_IsOK(res1)) {
44783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44784 }
44785 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44786 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44787 if (!SWIG_IsOK(ecode2)) {
44788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44789 }
44790 arg2 = static_cast< size_t >(val2);
44791 {
44792 PyThreadState* __tstate = wxPyBeginAllowThreads();
44793 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44794 wxPyEndAllowThreads(__tstate);
44795 if (PyErr_Occurred()) SWIG_fail;
44796 }
44797 {
44798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44799 }
44800 return resultobj;
44801 fail:
44802 return NULL;
44803 }
44804
44805
44806 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44807 PyObject *resultobj = 0;
44808 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44809 size_t arg2 ;
44810 wxString *arg3 = 0 ;
44811 void *argp1 = 0 ;
44812 int res1 = 0 ;
44813 size_t val2 ;
44814 int ecode2 = 0 ;
44815 bool temp3 = false ;
44816 PyObject * obj0 = 0 ;
44817 PyObject * obj1 = 0 ;
44818 PyObject * obj2 = 0 ;
44819 char * kwnames[] = {
44820 (char *) "self",(char *) "pos",(char *) "label", NULL
44821 };
44822
44823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44825 if (!SWIG_IsOK(res1)) {
44826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44827 }
44828 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44829 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44830 if (!SWIG_IsOK(ecode2)) {
44831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44832 }
44833 arg2 = static_cast< size_t >(val2);
44834 {
44835 arg3 = wxString_in_helper(obj2);
44836 if (arg3 == NULL) SWIG_fail;
44837 temp3 = true;
44838 }
44839 {
44840 PyThreadState* __tstate = wxPyBeginAllowThreads();
44841 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44842 wxPyEndAllowThreads(__tstate);
44843 if (PyErr_Occurred()) SWIG_fail;
44844 }
44845 resultobj = SWIG_Py_Void();
44846 {
44847 if (temp3)
44848 delete arg3;
44849 }
44850 return resultobj;
44851 fail:
44852 {
44853 if (temp3)
44854 delete arg3;
44855 }
44856 return NULL;
44857 }
44858
44859
44860 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44861 PyObject *resultobj = 0;
44862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44863 size_t arg2 ;
44864 wxString result;
44865 void *argp1 = 0 ;
44866 int res1 = 0 ;
44867 size_t val2 ;
44868 int ecode2 = 0 ;
44869 PyObject * obj0 = 0 ;
44870 PyObject * obj1 = 0 ;
44871 char * kwnames[] = {
44872 (char *) "self",(char *) "pos", NULL
44873 };
44874
44875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44877 if (!SWIG_IsOK(res1)) {
44878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44879 }
44880 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44881 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44882 if (!SWIG_IsOK(ecode2)) {
44883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44884 }
44885 arg2 = static_cast< size_t >(val2);
44886 {
44887 PyThreadState* __tstate = wxPyBeginAllowThreads();
44888 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44889 wxPyEndAllowThreads(__tstate);
44890 if (PyErr_Occurred()) SWIG_fail;
44891 }
44892 {
44893 #if wxUSE_UNICODE
44894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44895 #else
44896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44897 #endif
44898 }
44899 return resultobj;
44900 fail:
44901 return NULL;
44902 }
44903
44904
44905 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44906 PyObject *resultobj = 0;
44907 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44908 wxString *arg2 = 0 ;
44909 wxString *arg3 = 0 ;
44910 int result;
44911 void *argp1 = 0 ;
44912 int res1 = 0 ;
44913 bool temp2 = false ;
44914 bool temp3 = false ;
44915 PyObject * obj0 = 0 ;
44916 PyObject * obj1 = 0 ;
44917 PyObject * obj2 = 0 ;
44918 char * kwnames[] = {
44919 (char *) "self",(char *) "menu",(char *) "item", NULL
44920 };
44921
44922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44924 if (!SWIG_IsOK(res1)) {
44925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44926 }
44927 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44928 {
44929 arg2 = wxString_in_helper(obj1);
44930 if (arg2 == NULL) SWIG_fail;
44931 temp2 = true;
44932 }
44933 {
44934 arg3 = wxString_in_helper(obj2);
44935 if (arg3 == NULL) SWIG_fail;
44936 temp3 = true;
44937 }
44938 {
44939 PyThreadState* __tstate = wxPyBeginAllowThreads();
44940 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44941 wxPyEndAllowThreads(__tstate);
44942 if (PyErr_Occurred()) SWIG_fail;
44943 }
44944 resultobj = SWIG_From_int(static_cast< int >(result));
44945 {
44946 if (temp2)
44947 delete arg2;
44948 }
44949 {
44950 if (temp3)
44951 delete arg3;
44952 }
44953 return resultobj;
44954 fail:
44955 {
44956 if (temp2)
44957 delete arg2;
44958 }
44959 {
44960 if (temp3)
44961 delete arg3;
44962 }
44963 return NULL;
44964 }
44965
44966
44967 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44968 PyObject *resultobj = 0;
44969 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44970 int arg2 ;
44971 wxMenuItem *result = 0 ;
44972 void *argp1 = 0 ;
44973 int res1 = 0 ;
44974 int val2 ;
44975 int ecode2 = 0 ;
44976 PyObject * obj0 = 0 ;
44977 PyObject * obj1 = 0 ;
44978 char * kwnames[] = {
44979 (char *) "self",(char *) "id", NULL
44980 };
44981
44982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44984 if (!SWIG_IsOK(res1)) {
44985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44986 }
44987 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44988 ecode2 = SWIG_AsVal_int(obj1, &val2);
44989 if (!SWIG_IsOK(ecode2)) {
44990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44991 }
44992 arg2 = static_cast< int >(val2);
44993 {
44994 PyThreadState* __tstate = wxPyBeginAllowThreads();
44995 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44996 wxPyEndAllowThreads(__tstate);
44997 if (PyErr_Occurred()) SWIG_fail;
44998 }
44999 {
45000 resultobj = wxPyMake_wxObject(result, (bool)0);
45001 }
45002 return resultobj;
45003 fail:
45004 return NULL;
45005 }
45006
45007
45008 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45009 PyObject *resultobj = 0;
45010 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45011 wxString *arg2 = 0 ;
45012 int result;
45013 void *argp1 = 0 ;
45014 int res1 = 0 ;
45015 bool temp2 = false ;
45016 PyObject * obj0 = 0 ;
45017 PyObject * obj1 = 0 ;
45018 char * kwnames[] = {
45019 (char *) "self",(char *) "title", NULL
45020 };
45021
45022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45024 if (!SWIG_IsOK(res1)) {
45025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45026 }
45027 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45028 {
45029 arg2 = wxString_in_helper(obj1);
45030 if (arg2 == NULL) SWIG_fail;
45031 temp2 = true;
45032 }
45033 {
45034 PyThreadState* __tstate = wxPyBeginAllowThreads();
45035 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45036 wxPyEndAllowThreads(__tstate);
45037 if (PyErr_Occurred()) SWIG_fail;
45038 }
45039 resultobj = SWIG_From_int(static_cast< int >(result));
45040 {
45041 if (temp2)
45042 delete arg2;
45043 }
45044 return resultobj;
45045 fail:
45046 {
45047 if (temp2)
45048 delete arg2;
45049 }
45050 return NULL;
45051 }
45052
45053
45054 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45055 PyObject *resultobj = 0;
45056 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45057 int arg2 ;
45058 bool arg3 ;
45059 void *argp1 = 0 ;
45060 int res1 = 0 ;
45061 int val2 ;
45062 int ecode2 = 0 ;
45063 bool val3 ;
45064 int ecode3 = 0 ;
45065 PyObject * obj0 = 0 ;
45066 PyObject * obj1 = 0 ;
45067 PyObject * obj2 = 0 ;
45068 char * kwnames[] = {
45069 (char *) "self",(char *) "id",(char *) "enable", NULL
45070 };
45071
45072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45074 if (!SWIG_IsOK(res1)) {
45075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45076 }
45077 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45078 ecode2 = SWIG_AsVal_int(obj1, &val2);
45079 if (!SWIG_IsOK(ecode2)) {
45080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45081 }
45082 arg2 = static_cast< int >(val2);
45083 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45084 if (!SWIG_IsOK(ecode3)) {
45085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45086 }
45087 arg3 = static_cast< bool >(val3);
45088 {
45089 PyThreadState* __tstate = wxPyBeginAllowThreads();
45090 (arg1)->Enable(arg2,arg3);
45091 wxPyEndAllowThreads(__tstate);
45092 if (PyErr_Occurred()) SWIG_fail;
45093 }
45094 resultobj = SWIG_Py_Void();
45095 return resultobj;
45096 fail:
45097 return NULL;
45098 }
45099
45100
45101 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45102 PyObject *resultobj = 0;
45103 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45104 int arg2 ;
45105 bool arg3 ;
45106 void *argp1 = 0 ;
45107 int res1 = 0 ;
45108 int val2 ;
45109 int ecode2 = 0 ;
45110 bool val3 ;
45111 int ecode3 = 0 ;
45112 PyObject * obj0 = 0 ;
45113 PyObject * obj1 = 0 ;
45114 PyObject * obj2 = 0 ;
45115 char * kwnames[] = {
45116 (char *) "self",(char *) "id",(char *) "check", NULL
45117 };
45118
45119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45121 if (!SWIG_IsOK(res1)) {
45122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45123 }
45124 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45125 ecode2 = SWIG_AsVal_int(obj1, &val2);
45126 if (!SWIG_IsOK(ecode2)) {
45127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45128 }
45129 arg2 = static_cast< int >(val2);
45130 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45131 if (!SWIG_IsOK(ecode3)) {
45132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45133 }
45134 arg3 = static_cast< bool >(val3);
45135 {
45136 PyThreadState* __tstate = wxPyBeginAllowThreads();
45137 (arg1)->Check(arg2,arg3);
45138 wxPyEndAllowThreads(__tstate);
45139 if (PyErr_Occurred()) SWIG_fail;
45140 }
45141 resultobj = SWIG_Py_Void();
45142 return resultobj;
45143 fail:
45144 return NULL;
45145 }
45146
45147
45148 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45149 PyObject *resultobj = 0;
45150 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45151 int arg2 ;
45152 bool result;
45153 void *argp1 = 0 ;
45154 int res1 = 0 ;
45155 int val2 ;
45156 int ecode2 = 0 ;
45157 PyObject * obj0 = 0 ;
45158 PyObject * obj1 = 0 ;
45159 char * kwnames[] = {
45160 (char *) "self",(char *) "id", NULL
45161 };
45162
45163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45165 if (!SWIG_IsOK(res1)) {
45166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45167 }
45168 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45169 ecode2 = SWIG_AsVal_int(obj1, &val2);
45170 if (!SWIG_IsOK(ecode2)) {
45171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45172 }
45173 arg2 = static_cast< int >(val2);
45174 {
45175 PyThreadState* __tstate = wxPyBeginAllowThreads();
45176 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45177 wxPyEndAllowThreads(__tstate);
45178 if (PyErr_Occurred()) SWIG_fail;
45179 }
45180 {
45181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45182 }
45183 return resultobj;
45184 fail:
45185 return NULL;
45186 }
45187
45188
45189 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45190 PyObject *resultobj = 0;
45191 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45192 int arg2 ;
45193 bool result;
45194 void *argp1 = 0 ;
45195 int res1 = 0 ;
45196 int val2 ;
45197 int ecode2 = 0 ;
45198 PyObject * obj0 = 0 ;
45199 PyObject * obj1 = 0 ;
45200 char * kwnames[] = {
45201 (char *) "self",(char *) "id", NULL
45202 };
45203
45204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45206 if (!SWIG_IsOK(res1)) {
45207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45208 }
45209 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45210 ecode2 = SWIG_AsVal_int(obj1, &val2);
45211 if (!SWIG_IsOK(ecode2)) {
45212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45213 }
45214 arg2 = static_cast< int >(val2);
45215 {
45216 PyThreadState* __tstate = wxPyBeginAllowThreads();
45217 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45218 wxPyEndAllowThreads(__tstate);
45219 if (PyErr_Occurred()) SWIG_fail;
45220 }
45221 {
45222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45223 }
45224 return resultobj;
45225 fail:
45226 return NULL;
45227 }
45228
45229
45230 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45231 PyObject *resultobj = 0;
45232 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45233 int arg2 ;
45234 wxString *arg3 = 0 ;
45235 void *argp1 = 0 ;
45236 int res1 = 0 ;
45237 int val2 ;
45238 int ecode2 = 0 ;
45239 bool temp3 = false ;
45240 PyObject * obj0 = 0 ;
45241 PyObject * obj1 = 0 ;
45242 PyObject * obj2 = 0 ;
45243 char * kwnames[] = {
45244 (char *) "self",(char *) "id",(char *) "label", NULL
45245 };
45246
45247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45249 if (!SWIG_IsOK(res1)) {
45250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45251 }
45252 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45253 ecode2 = SWIG_AsVal_int(obj1, &val2);
45254 if (!SWIG_IsOK(ecode2)) {
45255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45256 }
45257 arg2 = static_cast< int >(val2);
45258 {
45259 arg3 = wxString_in_helper(obj2);
45260 if (arg3 == NULL) SWIG_fail;
45261 temp3 = true;
45262 }
45263 {
45264 PyThreadState* __tstate = wxPyBeginAllowThreads();
45265 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45266 wxPyEndAllowThreads(__tstate);
45267 if (PyErr_Occurred()) SWIG_fail;
45268 }
45269 resultobj = SWIG_Py_Void();
45270 {
45271 if (temp3)
45272 delete arg3;
45273 }
45274 return resultobj;
45275 fail:
45276 {
45277 if (temp3)
45278 delete arg3;
45279 }
45280 return NULL;
45281 }
45282
45283
45284 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45285 PyObject *resultobj = 0;
45286 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45287 int arg2 ;
45288 wxString result;
45289 void *argp1 = 0 ;
45290 int res1 = 0 ;
45291 int val2 ;
45292 int ecode2 = 0 ;
45293 PyObject * obj0 = 0 ;
45294 PyObject * obj1 = 0 ;
45295 char * kwnames[] = {
45296 (char *) "self",(char *) "id", NULL
45297 };
45298
45299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45301 if (!SWIG_IsOK(res1)) {
45302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45303 }
45304 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45305 ecode2 = SWIG_AsVal_int(obj1, &val2);
45306 if (!SWIG_IsOK(ecode2)) {
45307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45308 }
45309 arg2 = static_cast< int >(val2);
45310 {
45311 PyThreadState* __tstate = wxPyBeginAllowThreads();
45312 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45313 wxPyEndAllowThreads(__tstate);
45314 if (PyErr_Occurred()) SWIG_fail;
45315 }
45316 {
45317 #if wxUSE_UNICODE
45318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45319 #else
45320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45321 #endif
45322 }
45323 return resultobj;
45324 fail:
45325 return NULL;
45326 }
45327
45328
45329 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45330 PyObject *resultobj = 0;
45331 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45332 int arg2 ;
45333 wxString *arg3 = 0 ;
45334 void *argp1 = 0 ;
45335 int res1 = 0 ;
45336 int val2 ;
45337 int ecode2 = 0 ;
45338 bool temp3 = false ;
45339 PyObject * obj0 = 0 ;
45340 PyObject * obj1 = 0 ;
45341 PyObject * obj2 = 0 ;
45342 char * kwnames[] = {
45343 (char *) "self",(char *) "id",(char *) "helpString", NULL
45344 };
45345
45346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45348 if (!SWIG_IsOK(res1)) {
45349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45350 }
45351 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45352 ecode2 = SWIG_AsVal_int(obj1, &val2);
45353 if (!SWIG_IsOK(ecode2)) {
45354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45355 }
45356 arg2 = static_cast< int >(val2);
45357 {
45358 arg3 = wxString_in_helper(obj2);
45359 if (arg3 == NULL) SWIG_fail;
45360 temp3 = true;
45361 }
45362 {
45363 PyThreadState* __tstate = wxPyBeginAllowThreads();
45364 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45365 wxPyEndAllowThreads(__tstate);
45366 if (PyErr_Occurred()) SWIG_fail;
45367 }
45368 resultobj = SWIG_Py_Void();
45369 {
45370 if (temp3)
45371 delete arg3;
45372 }
45373 return resultobj;
45374 fail:
45375 {
45376 if (temp3)
45377 delete arg3;
45378 }
45379 return NULL;
45380 }
45381
45382
45383 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45384 PyObject *resultobj = 0;
45385 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45386 int arg2 ;
45387 wxString result;
45388 void *argp1 = 0 ;
45389 int res1 = 0 ;
45390 int val2 ;
45391 int ecode2 = 0 ;
45392 PyObject * obj0 = 0 ;
45393 PyObject * obj1 = 0 ;
45394 char * kwnames[] = {
45395 (char *) "self",(char *) "id", NULL
45396 };
45397
45398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45400 if (!SWIG_IsOK(res1)) {
45401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45402 }
45403 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45404 ecode2 = SWIG_AsVal_int(obj1, &val2);
45405 if (!SWIG_IsOK(ecode2)) {
45406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45407 }
45408 arg2 = static_cast< int >(val2);
45409 {
45410 PyThreadState* __tstate = wxPyBeginAllowThreads();
45411 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45412 wxPyEndAllowThreads(__tstate);
45413 if (PyErr_Occurred()) SWIG_fail;
45414 }
45415 {
45416 #if wxUSE_UNICODE
45417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45418 #else
45419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45420 #endif
45421 }
45422 return resultobj;
45423 fail:
45424 return NULL;
45425 }
45426
45427
45428 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45429 PyObject *resultobj = 0;
45430 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45431 wxFrame *result = 0 ;
45432 void *argp1 = 0 ;
45433 int res1 = 0 ;
45434 PyObject *swig_obj[1] ;
45435
45436 if (!args) SWIG_fail;
45437 swig_obj[0] = args;
45438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45439 if (!SWIG_IsOK(res1)) {
45440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45441 }
45442 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45443 {
45444 PyThreadState* __tstate = wxPyBeginAllowThreads();
45445 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45446 wxPyEndAllowThreads(__tstate);
45447 if (PyErr_Occurred()) SWIG_fail;
45448 }
45449 {
45450 resultobj = wxPyMake_wxObject(result, (bool)0);
45451 }
45452 return resultobj;
45453 fail:
45454 return NULL;
45455 }
45456
45457
45458 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45459 PyObject *resultobj = 0;
45460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45461 bool result;
45462 void *argp1 = 0 ;
45463 int res1 = 0 ;
45464 PyObject *swig_obj[1] ;
45465
45466 if (!args) SWIG_fail;
45467 swig_obj[0] = args;
45468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45469 if (!SWIG_IsOK(res1)) {
45470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45471 }
45472 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45473 {
45474 PyThreadState* __tstate = wxPyBeginAllowThreads();
45475 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45476 wxPyEndAllowThreads(__tstate);
45477 if (PyErr_Occurred()) SWIG_fail;
45478 }
45479 {
45480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45481 }
45482 return resultobj;
45483 fail:
45484 return NULL;
45485 }
45486
45487
45488 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45489 PyObject *resultobj = 0;
45490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45491 wxFrame *arg2 = (wxFrame *) 0 ;
45492 void *argp1 = 0 ;
45493 int res1 = 0 ;
45494 void *argp2 = 0 ;
45495 int res2 = 0 ;
45496 PyObject * obj0 = 0 ;
45497 PyObject * obj1 = 0 ;
45498 char * kwnames[] = {
45499 (char *) "self",(char *) "frame", NULL
45500 };
45501
45502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45504 if (!SWIG_IsOK(res1)) {
45505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45506 }
45507 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45509 if (!SWIG_IsOK(res2)) {
45510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45511 }
45512 arg2 = reinterpret_cast< wxFrame * >(argp2);
45513 {
45514 PyThreadState* __tstate = wxPyBeginAllowThreads();
45515 (arg1)->Attach(arg2);
45516 wxPyEndAllowThreads(__tstate);
45517 if (PyErr_Occurred()) SWIG_fail;
45518 }
45519 resultobj = SWIG_Py_Void();
45520 return resultobj;
45521 fail:
45522 return NULL;
45523 }
45524
45525
45526 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45527 PyObject *resultobj = 0;
45528 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45529 void *argp1 = 0 ;
45530 int res1 = 0 ;
45531 PyObject *swig_obj[1] ;
45532
45533 if (!args) SWIG_fail;
45534 swig_obj[0] = args;
45535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45536 if (!SWIG_IsOK(res1)) {
45537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45538 }
45539 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 (arg1)->Detach();
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 resultobj = SWIG_Py_Void();
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45554 PyObject *resultobj = 0;
45555 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45556 void *argp1 = 0 ;
45557 int res1 = 0 ;
45558 PyObject *swig_obj[1] ;
45559
45560 if (!args) SWIG_fail;
45561 swig_obj[0] = args;
45562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45563 if (!SWIG_IsOK(res1)) {
45564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45565 }
45566 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45567 {
45568 PyThreadState* __tstate = wxPyBeginAllowThreads();
45569 (arg1)->UpdateMenus();
45570 wxPyEndAllowThreads(__tstate);
45571 if (PyErr_Occurred()) SWIG_fail;
45572 }
45573 resultobj = SWIG_Py_Void();
45574 return resultobj;
45575 fail:
45576 return NULL;
45577 }
45578
45579
45580 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45581 PyObject *resultobj = 0;
45582 bool arg1 ;
45583 bool val1 ;
45584 int ecode1 = 0 ;
45585 PyObject * obj0 = 0 ;
45586 char * kwnames[] = {
45587 (char *) "enable", NULL
45588 };
45589
45590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45591 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45592 if (!SWIG_IsOK(ecode1)) {
45593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45594 }
45595 arg1 = static_cast< bool >(val1);
45596 {
45597 PyThreadState* __tstate = wxPyBeginAllowThreads();
45598 wxMenuBar_SetAutoWindowMenu(arg1);
45599 wxPyEndAllowThreads(__tstate);
45600 if (PyErr_Occurred()) SWIG_fail;
45601 }
45602 resultobj = SWIG_Py_Void();
45603 return resultobj;
45604 fail:
45605 return NULL;
45606 }
45607
45608
45609 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45610 PyObject *resultobj = 0;
45611 bool result;
45612
45613 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45614 {
45615 PyThreadState* __tstate = wxPyBeginAllowThreads();
45616 result = (bool)wxMenuBar_GetAutoWindowMenu();
45617 wxPyEndAllowThreads(__tstate);
45618 if (PyErr_Occurred()) SWIG_fail;
45619 }
45620 {
45621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45622 }
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45630 PyObject *obj;
45631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45632 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45633 return SWIG_Py_Void();
45634 }
45635
45636 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45637 return SWIG_Python_InitShadowInstance(args);
45638 }
45639
45640 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45641 PyObject *resultobj = 0;
45642 wxMenu *arg1 = (wxMenu *) NULL ;
45643 int arg2 = (int) wxID_ANY ;
45644 wxString const &arg3_defvalue = wxPyEmptyString ;
45645 wxString *arg3 = (wxString *) &arg3_defvalue ;
45646 wxString const &arg4_defvalue = wxPyEmptyString ;
45647 wxString *arg4 = (wxString *) &arg4_defvalue ;
45648 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45649 wxMenu *arg6 = (wxMenu *) NULL ;
45650 wxMenuItem *result = 0 ;
45651 void *argp1 = 0 ;
45652 int res1 = 0 ;
45653 int val2 ;
45654 int ecode2 = 0 ;
45655 bool temp3 = false ;
45656 bool temp4 = false ;
45657 int val5 ;
45658 int ecode5 = 0 ;
45659 void *argp6 = 0 ;
45660 int res6 = 0 ;
45661 PyObject * obj0 = 0 ;
45662 PyObject * obj1 = 0 ;
45663 PyObject * obj2 = 0 ;
45664 PyObject * obj3 = 0 ;
45665 PyObject * obj4 = 0 ;
45666 PyObject * obj5 = 0 ;
45667 char * kwnames[] = {
45668 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45669 };
45670
45671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45672 if (obj0) {
45673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45674 if (!SWIG_IsOK(res1)) {
45675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45676 }
45677 arg1 = reinterpret_cast< wxMenu * >(argp1);
45678 }
45679 if (obj1) {
45680 ecode2 = SWIG_AsVal_int(obj1, &val2);
45681 if (!SWIG_IsOK(ecode2)) {
45682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45683 }
45684 arg2 = static_cast< int >(val2);
45685 }
45686 if (obj2) {
45687 {
45688 arg3 = wxString_in_helper(obj2);
45689 if (arg3 == NULL) SWIG_fail;
45690 temp3 = true;
45691 }
45692 }
45693 if (obj3) {
45694 {
45695 arg4 = wxString_in_helper(obj3);
45696 if (arg4 == NULL) SWIG_fail;
45697 temp4 = true;
45698 }
45699 }
45700 if (obj4) {
45701 ecode5 = SWIG_AsVal_int(obj4, &val5);
45702 if (!SWIG_IsOK(ecode5)) {
45703 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45704 }
45705 arg5 = static_cast< wxItemKind >(val5);
45706 }
45707 if (obj5) {
45708 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45709 if (!SWIG_IsOK(res6)) {
45710 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45711 }
45712 arg6 = reinterpret_cast< wxMenu * >(argp6);
45713 }
45714 {
45715 PyThreadState* __tstate = wxPyBeginAllowThreads();
45716 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45717 wxPyEndAllowThreads(__tstate);
45718 if (PyErr_Occurred()) SWIG_fail;
45719 }
45720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45721 {
45722 if (temp3)
45723 delete arg3;
45724 }
45725 {
45726 if (temp4)
45727 delete arg4;
45728 }
45729 return resultobj;
45730 fail:
45731 {
45732 if (temp3)
45733 delete arg3;
45734 }
45735 {
45736 if (temp4)
45737 delete arg4;
45738 }
45739 return NULL;
45740 }
45741
45742
45743 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45744 PyObject *resultobj = 0;
45745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45746 void *argp1 = 0 ;
45747 int res1 = 0 ;
45748 PyObject *swig_obj[1] ;
45749
45750 if (!args) SWIG_fail;
45751 swig_obj[0] = args;
45752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45753 if (!SWIG_IsOK(res1)) {
45754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45755 }
45756 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45757 {
45758 PyThreadState* __tstate = wxPyBeginAllowThreads();
45759 delete arg1;
45760
45761 wxPyEndAllowThreads(__tstate);
45762 if (PyErr_Occurred()) SWIG_fail;
45763 }
45764 resultobj = SWIG_Py_Void();
45765 return resultobj;
45766 fail:
45767 return NULL;
45768 }
45769
45770
45771 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45772 PyObject *resultobj = 0;
45773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45774 wxMenu *result = 0 ;
45775 void *argp1 = 0 ;
45776 int res1 = 0 ;
45777 PyObject *swig_obj[1] ;
45778
45779 if (!args) SWIG_fail;
45780 swig_obj[0] = args;
45781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45782 if (!SWIG_IsOK(res1)) {
45783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45784 }
45785 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45786 {
45787 PyThreadState* __tstate = wxPyBeginAllowThreads();
45788 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45789 wxPyEndAllowThreads(__tstate);
45790 if (PyErr_Occurred()) SWIG_fail;
45791 }
45792 {
45793 resultobj = wxPyMake_wxObject(result, 0);
45794 }
45795 return resultobj;
45796 fail:
45797 return NULL;
45798 }
45799
45800
45801 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45802 PyObject *resultobj = 0;
45803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45804 wxMenu *arg2 = (wxMenu *) 0 ;
45805 void *argp1 = 0 ;
45806 int res1 = 0 ;
45807 void *argp2 = 0 ;
45808 int res2 = 0 ;
45809 PyObject * obj0 = 0 ;
45810 PyObject * obj1 = 0 ;
45811 char * kwnames[] = {
45812 (char *) "self",(char *) "menu", NULL
45813 };
45814
45815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45817 if (!SWIG_IsOK(res1)) {
45818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45819 }
45820 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45822 if (!SWIG_IsOK(res2)) {
45823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45824 }
45825 arg2 = reinterpret_cast< wxMenu * >(argp2);
45826 {
45827 PyThreadState* __tstate = wxPyBeginAllowThreads();
45828 (arg1)->SetMenu(arg2);
45829 wxPyEndAllowThreads(__tstate);
45830 if (PyErr_Occurred()) SWIG_fail;
45831 }
45832 resultobj = SWIG_Py_Void();
45833 return resultobj;
45834 fail:
45835 return NULL;
45836 }
45837
45838
45839 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45840 PyObject *resultobj = 0;
45841 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45842 int arg2 ;
45843 void *argp1 = 0 ;
45844 int res1 = 0 ;
45845 int val2 ;
45846 int ecode2 = 0 ;
45847 PyObject * obj0 = 0 ;
45848 PyObject * obj1 = 0 ;
45849 char * kwnames[] = {
45850 (char *) "self",(char *) "id", NULL
45851 };
45852
45853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45855 if (!SWIG_IsOK(res1)) {
45856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45857 }
45858 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45859 ecode2 = SWIG_AsVal_int(obj1, &val2);
45860 if (!SWIG_IsOK(ecode2)) {
45861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45862 }
45863 arg2 = static_cast< int >(val2);
45864 {
45865 PyThreadState* __tstate = wxPyBeginAllowThreads();
45866 (arg1)->SetId(arg2);
45867 wxPyEndAllowThreads(__tstate);
45868 if (PyErr_Occurred()) SWIG_fail;
45869 }
45870 resultobj = SWIG_Py_Void();
45871 return resultobj;
45872 fail:
45873 return NULL;
45874 }
45875
45876
45877 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45878 PyObject *resultobj = 0;
45879 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45880 int result;
45881 void *argp1 = 0 ;
45882 int res1 = 0 ;
45883 PyObject *swig_obj[1] ;
45884
45885 if (!args) SWIG_fail;
45886 swig_obj[0] = args;
45887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45888 if (!SWIG_IsOK(res1)) {
45889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45890 }
45891 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45892 {
45893 PyThreadState* __tstate = wxPyBeginAllowThreads();
45894 result = (int)((wxMenuItem const *)arg1)->GetId();
45895 wxPyEndAllowThreads(__tstate);
45896 if (PyErr_Occurred()) SWIG_fail;
45897 }
45898 resultobj = SWIG_From_int(static_cast< int >(result));
45899 return resultobj;
45900 fail:
45901 return NULL;
45902 }
45903
45904
45905 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45906 PyObject *resultobj = 0;
45907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45908 bool result;
45909 void *argp1 = 0 ;
45910 int res1 = 0 ;
45911 PyObject *swig_obj[1] ;
45912
45913 if (!args) SWIG_fail;
45914 swig_obj[0] = args;
45915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45916 if (!SWIG_IsOK(res1)) {
45917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45918 }
45919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45920 {
45921 PyThreadState* __tstate = wxPyBeginAllowThreads();
45922 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45923 wxPyEndAllowThreads(__tstate);
45924 if (PyErr_Occurred()) SWIG_fail;
45925 }
45926 {
45927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45928 }
45929 return resultobj;
45930 fail:
45931 return NULL;
45932 }
45933
45934
45935 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45936 PyObject *resultobj = 0;
45937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45938 wxString *arg2 = 0 ;
45939 void *argp1 = 0 ;
45940 int res1 = 0 ;
45941 bool temp2 = false ;
45942 PyObject * obj0 = 0 ;
45943 PyObject * obj1 = 0 ;
45944 char * kwnames[] = {
45945 (char *) "self",(char *) "str", NULL
45946 };
45947
45948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45950 if (!SWIG_IsOK(res1)) {
45951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45952 }
45953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45954 {
45955 arg2 = wxString_in_helper(obj1);
45956 if (arg2 == NULL) SWIG_fail;
45957 temp2 = true;
45958 }
45959 {
45960 PyThreadState* __tstate = wxPyBeginAllowThreads();
45961 (arg1)->SetText((wxString const &)*arg2);
45962 wxPyEndAllowThreads(__tstate);
45963 if (PyErr_Occurred()) SWIG_fail;
45964 }
45965 resultobj = SWIG_Py_Void();
45966 {
45967 if (temp2)
45968 delete arg2;
45969 }
45970 return resultobj;
45971 fail:
45972 {
45973 if (temp2)
45974 delete arg2;
45975 }
45976 return NULL;
45977 }
45978
45979
45980 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45981 PyObject *resultobj = 0;
45982 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45983 wxString result;
45984 void *argp1 = 0 ;
45985 int res1 = 0 ;
45986 PyObject *swig_obj[1] ;
45987
45988 if (!args) SWIG_fail;
45989 swig_obj[0] = args;
45990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45991 if (!SWIG_IsOK(res1)) {
45992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45993 }
45994 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 result = ((wxMenuItem const *)arg1)->GetLabel();
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 {
46002 #if wxUSE_UNICODE
46003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46004 #else
46005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46006 #endif
46007 }
46008 return resultobj;
46009 fail:
46010 return NULL;
46011 }
46012
46013
46014 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46015 PyObject *resultobj = 0;
46016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46017 wxString *result = 0 ;
46018 void *argp1 = 0 ;
46019 int res1 = 0 ;
46020 PyObject *swig_obj[1] ;
46021
46022 if (!args) SWIG_fail;
46023 swig_obj[0] = args;
46024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46025 if (!SWIG_IsOK(res1)) {
46026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46027 }
46028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46029 {
46030 PyThreadState* __tstate = wxPyBeginAllowThreads();
46031 {
46032 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46033 result = (wxString *) &_result_ref;
46034 }
46035 wxPyEndAllowThreads(__tstate);
46036 if (PyErr_Occurred()) SWIG_fail;
46037 }
46038 {
46039 #if wxUSE_UNICODE
46040 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46041 #else
46042 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46043 #endif
46044 }
46045 return resultobj;
46046 fail:
46047 return NULL;
46048 }
46049
46050
46051 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46052 PyObject *resultobj = 0;
46053 wxString *arg1 = 0 ;
46054 wxString result;
46055 bool temp1 = false ;
46056 PyObject * obj0 = 0 ;
46057 char * kwnames[] = {
46058 (char *) "text", NULL
46059 };
46060
46061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46062 {
46063 arg1 = wxString_in_helper(obj0);
46064 if (arg1 == NULL) SWIG_fail;
46065 temp1 = true;
46066 }
46067 {
46068 PyThreadState* __tstate = wxPyBeginAllowThreads();
46069 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46070 wxPyEndAllowThreads(__tstate);
46071 if (PyErr_Occurred()) SWIG_fail;
46072 }
46073 {
46074 #if wxUSE_UNICODE
46075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46076 #else
46077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46078 #endif
46079 }
46080 {
46081 if (temp1)
46082 delete arg1;
46083 }
46084 return resultobj;
46085 fail:
46086 {
46087 if (temp1)
46088 delete arg1;
46089 }
46090 return NULL;
46091 }
46092
46093
46094 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46095 PyObject *resultobj = 0;
46096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46097 wxItemKind result;
46098 void *argp1 = 0 ;
46099 int res1 = 0 ;
46100 PyObject *swig_obj[1] ;
46101
46102 if (!args) SWIG_fail;
46103 swig_obj[0] = args;
46104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46105 if (!SWIG_IsOK(res1)) {
46106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46107 }
46108 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_From_int(static_cast< int >(result));
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46123 PyObject *resultobj = 0;
46124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46125 wxItemKind arg2 ;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 int val2 ;
46129 int ecode2 = 0 ;
46130 PyObject * obj0 = 0 ;
46131 PyObject * obj1 = 0 ;
46132 char * kwnames[] = {
46133 (char *) "self",(char *) "kind", NULL
46134 };
46135
46136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46138 if (!SWIG_IsOK(res1)) {
46139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46140 }
46141 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46142 ecode2 = SWIG_AsVal_int(obj1, &val2);
46143 if (!SWIG_IsOK(ecode2)) {
46144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46145 }
46146 arg2 = static_cast< wxItemKind >(val2);
46147 {
46148 PyThreadState* __tstate = wxPyBeginAllowThreads();
46149 (arg1)->SetKind(arg2);
46150 wxPyEndAllowThreads(__tstate);
46151 if (PyErr_Occurred()) SWIG_fail;
46152 }
46153 resultobj = SWIG_Py_Void();
46154 return resultobj;
46155 fail:
46156 return NULL;
46157 }
46158
46159
46160 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46161 PyObject *resultobj = 0;
46162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46163 bool arg2 ;
46164 void *argp1 = 0 ;
46165 int res1 = 0 ;
46166 bool val2 ;
46167 int ecode2 = 0 ;
46168 PyObject * obj0 = 0 ;
46169 PyObject * obj1 = 0 ;
46170 char * kwnames[] = {
46171 (char *) "self",(char *) "checkable", NULL
46172 };
46173
46174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46178 }
46179 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46181 if (!SWIG_IsOK(ecode2)) {
46182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46183 }
46184 arg2 = static_cast< bool >(val2);
46185 {
46186 PyThreadState* __tstate = wxPyBeginAllowThreads();
46187 (arg1)->SetCheckable(arg2);
46188 wxPyEndAllowThreads(__tstate);
46189 if (PyErr_Occurred()) SWIG_fail;
46190 }
46191 resultobj = SWIG_Py_Void();
46192 return resultobj;
46193 fail:
46194 return NULL;
46195 }
46196
46197
46198 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46199 PyObject *resultobj = 0;
46200 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46201 bool result;
46202 void *argp1 = 0 ;
46203 int res1 = 0 ;
46204 PyObject *swig_obj[1] ;
46205
46206 if (!args) SWIG_fail;
46207 swig_obj[0] = args;
46208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46209 if (!SWIG_IsOK(res1)) {
46210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46211 }
46212 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46213 {
46214 PyThreadState* __tstate = wxPyBeginAllowThreads();
46215 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46216 wxPyEndAllowThreads(__tstate);
46217 if (PyErr_Occurred()) SWIG_fail;
46218 }
46219 {
46220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46221 }
46222 return resultobj;
46223 fail:
46224 return NULL;
46225 }
46226
46227
46228 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46229 PyObject *resultobj = 0;
46230 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46231 bool result;
46232 void *argp1 = 0 ;
46233 int res1 = 0 ;
46234 PyObject *swig_obj[1] ;
46235
46236 if (!args) SWIG_fail;
46237 swig_obj[0] = args;
46238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46239 if (!SWIG_IsOK(res1)) {
46240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46241 }
46242 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46243 {
46244 PyThreadState* __tstate = wxPyBeginAllowThreads();
46245 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46246 wxPyEndAllowThreads(__tstate);
46247 if (PyErr_Occurred()) SWIG_fail;
46248 }
46249 {
46250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46251 }
46252 return resultobj;
46253 fail:
46254 return NULL;
46255 }
46256
46257
46258 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46259 PyObject *resultobj = 0;
46260 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46261 wxMenu *arg2 = (wxMenu *) 0 ;
46262 void *argp1 = 0 ;
46263 int res1 = 0 ;
46264 void *argp2 = 0 ;
46265 int res2 = 0 ;
46266 PyObject * obj0 = 0 ;
46267 PyObject * obj1 = 0 ;
46268 char * kwnames[] = {
46269 (char *) "self",(char *) "menu", NULL
46270 };
46271
46272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46274 if (!SWIG_IsOK(res1)) {
46275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46276 }
46277 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46279 if (!SWIG_IsOK(res2)) {
46280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46281 }
46282 arg2 = reinterpret_cast< wxMenu * >(argp2);
46283 {
46284 PyThreadState* __tstate = wxPyBeginAllowThreads();
46285 (arg1)->SetSubMenu(arg2);
46286 wxPyEndAllowThreads(__tstate);
46287 if (PyErr_Occurred()) SWIG_fail;
46288 }
46289 resultobj = SWIG_Py_Void();
46290 return resultobj;
46291 fail:
46292 return NULL;
46293 }
46294
46295
46296 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46297 PyObject *resultobj = 0;
46298 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46299 wxMenu *result = 0 ;
46300 void *argp1 = 0 ;
46301 int res1 = 0 ;
46302 PyObject *swig_obj[1] ;
46303
46304 if (!args) SWIG_fail;
46305 swig_obj[0] = args;
46306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46307 if (!SWIG_IsOK(res1)) {
46308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46309 }
46310 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46311 {
46312 PyThreadState* __tstate = wxPyBeginAllowThreads();
46313 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46314 wxPyEndAllowThreads(__tstate);
46315 if (PyErr_Occurred()) SWIG_fail;
46316 }
46317 {
46318 resultobj = wxPyMake_wxObject(result, 0);
46319 }
46320 return resultobj;
46321 fail:
46322 return NULL;
46323 }
46324
46325
46326 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46327 PyObject *resultobj = 0;
46328 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46329 bool arg2 = (bool) true ;
46330 void *argp1 = 0 ;
46331 int res1 = 0 ;
46332 bool val2 ;
46333 int ecode2 = 0 ;
46334 PyObject * obj0 = 0 ;
46335 PyObject * obj1 = 0 ;
46336 char * kwnames[] = {
46337 (char *) "self",(char *) "enable", NULL
46338 };
46339
46340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46342 if (!SWIG_IsOK(res1)) {
46343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46344 }
46345 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46346 if (obj1) {
46347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46348 if (!SWIG_IsOK(ecode2)) {
46349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46350 }
46351 arg2 = static_cast< bool >(val2);
46352 }
46353 {
46354 PyThreadState* __tstate = wxPyBeginAllowThreads();
46355 (arg1)->Enable(arg2);
46356 wxPyEndAllowThreads(__tstate);
46357 if (PyErr_Occurred()) SWIG_fail;
46358 }
46359 resultobj = SWIG_Py_Void();
46360 return resultobj;
46361 fail:
46362 return NULL;
46363 }
46364
46365
46366 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46367 PyObject *resultobj = 0;
46368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46369 bool result;
46370 void *argp1 = 0 ;
46371 int res1 = 0 ;
46372 PyObject *swig_obj[1] ;
46373
46374 if (!args) SWIG_fail;
46375 swig_obj[0] = args;
46376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46377 if (!SWIG_IsOK(res1)) {
46378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46379 }
46380 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46381 {
46382 PyThreadState* __tstate = wxPyBeginAllowThreads();
46383 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46384 wxPyEndAllowThreads(__tstate);
46385 if (PyErr_Occurred()) SWIG_fail;
46386 }
46387 {
46388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46389 }
46390 return resultobj;
46391 fail:
46392 return NULL;
46393 }
46394
46395
46396 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46397 PyObject *resultobj = 0;
46398 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46399 bool arg2 = (bool) true ;
46400 void *argp1 = 0 ;
46401 int res1 = 0 ;
46402 bool val2 ;
46403 int ecode2 = 0 ;
46404 PyObject * obj0 = 0 ;
46405 PyObject * obj1 = 0 ;
46406 char * kwnames[] = {
46407 (char *) "self",(char *) "check", NULL
46408 };
46409
46410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46412 if (!SWIG_IsOK(res1)) {
46413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46414 }
46415 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46416 if (obj1) {
46417 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46418 if (!SWIG_IsOK(ecode2)) {
46419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46420 }
46421 arg2 = static_cast< bool >(val2);
46422 }
46423 {
46424 PyThreadState* __tstate = wxPyBeginAllowThreads();
46425 (arg1)->Check(arg2);
46426 wxPyEndAllowThreads(__tstate);
46427 if (PyErr_Occurred()) SWIG_fail;
46428 }
46429 resultobj = SWIG_Py_Void();
46430 return resultobj;
46431 fail:
46432 return NULL;
46433 }
46434
46435
46436 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46437 PyObject *resultobj = 0;
46438 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46439 bool result;
46440 void *argp1 = 0 ;
46441 int res1 = 0 ;
46442 PyObject *swig_obj[1] ;
46443
46444 if (!args) SWIG_fail;
46445 swig_obj[0] = args;
46446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46447 if (!SWIG_IsOK(res1)) {
46448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46449 }
46450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46451 {
46452 PyThreadState* __tstate = wxPyBeginAllowThreads();
46453 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46454 wxPyEndAllowThreads(__tstate);
46455 if (PyErr_Occurred()) SWIG_fail;
46456 }
46457 {
46458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46459 }
46460 return resultobj;
46461 fail:
46462 return NULL;
46463 }
46464
46465
46466 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46467 PyObject *resultobj = 0;
46468 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46469 void *argp1 = 0 ;
46470 int res1 = 0 ;
46471 PyObject *swig_obj[1] ;
46472
46473 if (!args) SWIG_fail;
46474 swig_obj[0] = args;
46475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46476 if (!SWIG_IsOK(res1)) {
46477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46478 }
46479 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46480 {
46481 PyThreadState* __tstate = wxPyBeginAllowThreads();
46482 (arg1)->Toggle();
46483 wxPyEndAllowThreads(__tstate);
46484 if (PyErr_Occurred()) SWIG_fail;
46485 }
46486 resultobj = SWIG_Py_Void();
46487 return resultobj;
46488 fail:
46489 return NULL;
46490 }
46491
46492
46493 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46494 PyObject *resultobj = 0;
46495 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46496 wxString *arg2 = 0 ;
46497 void *argp1 = 0 ;
46498 int res1 = 0 ;
46499 bool temp2 = false ;
46500 PyObject * obj0 = 0 ;
46501 PyObject * obj1 = 0 ;
46502 char * kwnames[] = {
46503 (char *) "self",(char *) "str", NULL
46504 };
46505
46506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46508 if (!SWIG_IsOK(res1)) {
46509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46510 }
46511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46512 {
46513 arg2 = wxString_in_helper(obj1);
46514 if (arg2 == NULL) SWIG_fail;
46515 temp2 = true;
46516 }
46517 {
46518 PyThreadState* __tstate = wxPyBeginAllowThreads();
46519 (arg1)->SetHelp((wxString const &)*arg2);
46520 wxPyEndAllowThreads(__tstate);
46521 if (PyErr_Occurred()) SWIG_fail;
46522 }
46523 resultobj = SWIG_Py_Void();
46524 {
46525 if (temp2)
46526 delete arg2;
46527 }
46528 return resultobj;
46529 fail:
46530 {
46531 if (temp2)
46532 delete arg2;
46533 }
46534 return NULL;
46535 }
46536
46537
46538 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46539 PyObject *resultobj = 0;
46540 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46541 wxString *result = 0 ;
46542 void *argp1 = 0 ;
46543 int res1 = 0 ;
46544 PyObject *swig_obj[1] ;
46545
46546 if (!args) SWIG_fail;
46547 swig_obj[0] = args;
46548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46549 if (!SWIG_IsOK(res1)) {
46550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46551 }
46552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46553 {
46554 PyThreadState* __tstate = wxPyBeginAllowThreads();
46555 {
46556 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46557 result = (wxString *) &_result_ref;
46558 }
46559 wxPyEndAllowThreads(__tstate);
46560 if (PyErr_Occurred()) SWIG_fail;
46561 }
46562 {
46563 #if wxUSE_UNICODE
46564 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46565 #else
46566 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46567 #endif
46568 }
46569 return resultobj;
46570 fail:
46571 return NULL;
46572 }
46573
46574
46575 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46576 PyObject *resultobj = 0;
46577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46578 wxAcceleratorEntry *result = 0 ;
46579 void *argp1 = 0 ;
46580 int res1 = 0 ;
46581 PyObject *swig_obj[1] ;
46582
46583 if (!args) SWIG_fail;
46584 swig_obj[0] = args;
46585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46586 if (!SWIG_IsOK(res1)) {
46587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46588 }
46589 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46590 {
46591 PyThreadState* __tstate = wxPyBeginAllowThreads();
46592 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46593 wxPyEndAllowThreads(__tstate);
46594 if (PyErr_Occurred()) SWIG_fail;
46595 }
46596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46597 return resultobj;
46598 fail:
46599 return NULL;
46600 }
46601
46602
46603 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46604 PyObject *resultobj = 0;
46605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46606 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46607 void *argp1 = 0 ;
46608 int res1 = 0 ;
46609 void *argp2 = 0 ;
46610 int res2 = 0 ;
46611 PyObject * obj0 = 0 ;
46612 PyObject * obj1 = 0 ;
46613 char * kwnames[] = {
46614 (char *) "self",(char *) "accel", NULL
46615 };
46616
46617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46621 }
46622 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46624 if (!SWIG_IsOK(res2)) {
46625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46626 }
46627 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46628 {
46629 PyThreadState* __tstate = wxPyBeginAllowThreads();
46630 (arg1)->SetAccel(arg2);
46631 wxPyEndAllowThreads(__tstate);
46632 if (PyErr_Occurred()) SWIG_fail;
46633 }
46634 resultobj = SWIG_Py_Void();
46635 return resultobj;
46636 fail:
46637 return NULL;
46638 }
46639
46640
46641 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46642 PyObject *resultobj = 0;
46643 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46644 wxBitmap *arg2 = 0 ;
46645 void *argp1 = 0 ;
46646 int res1 = 0 ;
46647 void *argp2 = 0 ;
46648 int res2 = 0 ;
46649 PyObject * obj0 = 0 ;
46650 PyObject * obj1 = 0 ;
46651 char * kwnames[] = {
46652 (char *) "self",(char *) "bitmap", NULL
46653 };
46654
46655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46659 }
46660 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46661 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46662 if (!SWIG_IsOK(res2)) {
46663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46664 }
46665 if (!argp2) {
46666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46667 }
46668 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46669 {
46670 PyThreadState* __tstate = wxPyBeginAllowThreads();
46671 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46672 wxPyEndAllowThreads(__tstate);
46673 if (PyErr_Occurred()) SWIG_fail;
46674 }
46675 resultobj = SWIG_Py_Void();
46676 return resultobj;
46677 fail:
46678 return NULL;
46679 }
46680
46681
46682 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46683 PyObject *resultobj = 0;
46684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46685 wxBitmap *result = 0 ;
46686 void *argp1 = 0 ;
46687 int res1 = 0 ;
46688 PyObject *swig_obj[1] ;
46689
46690 if (!args) SWIG_fail;
46691 swig_obj[0] = args;
46692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46693 if (!SWIG_IsOK(res1)) {
46694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46695 }
46696 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46697 {
46698 PyThreadState* __tstate = wxPyBeginAllowThreads();
46699 {
46700 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46701 result = (wxBitmap *) &_result_ref;
46702 }
46703 wxPyEndAllowThreads(__tstate);
46704 if (PyErr_Occurred()) SWIG_fail;
46705 }
46706 {
46707 wxBitmap* resultptr = new wxBitmap(*result);
46708 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46709 }
46710 return resultobj;
46711 fail:
46712 return NULL;
46713 }
46714
46715
46716 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46717 PyObject *resultobj = 0;
46718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46719 wxFont *arg2 = 0 ;
46720 void *argp1 = 0 ;
46721 int res1 = 0 ;
46722 void *argp2 = 0 ;
46723 int res2 = 0 ;
46724 PyObject * obj0 = 0 ;
46725 PyObject * obj1 = 0 ;
46726 char * kwnames[] = {
46727 (char *) "self",(char *) "font", NULL
46728 };
46729
46730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46732 if (!SWIG_IsOK(res1)) {
46733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46734 }
46735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46737 if (!SWIG_IsOK(res2)) {
46738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46739 }
46740 if (!argp2) {
46741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46742 }
46743 arg2 = reinterpret_cast< wxFont * >(argp2);
46744 {
46745 PyThreadState* __tstate = wxPyBeginAllowThreads();
46746 (arg1)->SetFont((wxFont const &)*arg2);
46747 wxPyEndAllowThreads(__tstate);
46748 if (PyErr_Occurred()) SWIG_fail;
46749 }
46750 resultobj = SWIG_Py_Void();
46751 return resultobj;
46752 fail:
46753 return NULL;
46754 }
46755
46756
46757 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46758 PyObject *resultobj = 0;
46759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46760 wxFont result;
46761 void *argp1 = 0 ;
46762 int res1 = 0 ;
46763 PyObject *swig_obj[1] ;
46764
46765 if (!args) SWIG_fail;
46766 swig_obj[0] = args;
46767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46768 if (!SWIG_IsOK(res1)) {
46769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46770 }
46771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 result = (arg1)->GetFont();
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46788 wxColour *arg2 = 0 ;
46789 void *argp1 = 0 ;
46790 int res1 = 0 ;
46791 wxColour temp2 ;
46792 PyObject * obj0 = 0 ;
46793 PyObject * obj1 = 0 ;
46794 char * kwnames[] = {
46795 (char *) "self",(char *) "colText", NULL
46796 };
46797
46798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46800 if (!SWIG_IsOK(res1)) {
46801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46802 }
46803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46804 {
46805 arg2 = &temp2;
46806 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46807 }
46808 {
46809 PyThreadState* __tstate = wxPyBeginAllowThreads();
46810 (arg1)->SetTextColour((wxColour const &)*arg2);
46811 wxPyEndAllowThreads(__tstate);
46812 if (PyErr_Occurred()) SWIG_fail;
46813 }
46814 resultobj = SWIG_Py_Void();
46815 return resultobj;
46816 fail:
46817 return NULL;
46818 }
46819
46820
46821 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46822 PyObject *resultobj = 0;
46823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46824 wxColour result;
46825 void *argp1 = 0 ;
46826 int res1 = 0 ;
46827 PyObject *swig_obj[1] ;
46828
46829 if (!args) SWIG_fail;
46830 swig_obj[0] = args;
46831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46832 if (!SWIG_IsOK(res1)) {
46833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46834 }
46835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46836 {
46837 PyThreadState* __tstate = wxPyBeginAllowThreads();
46838 result = (arg1)->GetTextColour();
46839 wxPyEndAllowThreads(__tstate);
46840 if (PyErr_Occurred()) SWIG_fail;
46841 }
46842 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46843 return resultobj;
46844 fail:
46845 return NULL;
46846 }
46847
46848
46849 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46850 PyObject *resultobj = 0;
46851 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46852 wxColour *arg2 = 0 ;
46853 void *argp1 = 0 ;
46854 int res1 = 0 ;
46855 wxColour temp2 ;
46856 PyObject * obj0 = 0 ;
46857 PyObject * obj1 = 0 ;
46858 char * kwnames[] = {
46859 (char *) "self",(char *) "colBack", NULL
46860 };
46861
46862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46864 if (!SWIG_IsOK(res1)) {
46865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46866 }
46867 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46868 {
46869 arg2 = &temp2;
46870 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46871 }
46872 {
46873 PyThreadState* __tstate = wxPyBeginAllowThreads();
46874 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46875 wxPyEndAllowThreads(__tstate);
46876 if (PyErr_Occurred()) SWIG_fail;
46877 }
46878 resultobj = SWIG_Py_Void();
46879 return resultobj;
46880 fail:
46881 return NULL;
46882 }
46883
46884
46885 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46886 PyObject *resultobj = 0;
46887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46888 wxColour result;
46889 void *argp1 = 0 ;
46890 int res1 = 0 ;
46891 PyObject *swig_obj[1] ;
46892
46893 if (!args) SWIG_fail;
46894 swig_obj[0] = args;
46895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46896 if (!SWIG_IsOK(res1)) {
46897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46898 }
46899 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46900 {
46901 PyThreadState* __tstate = wxPyBeginAllowThreads();
46902 result = (arg1)->GetBackgroundColour();
46903 wxPyEndAllowThreads(__tstate);
46904 if (PyErr_Occurred()) SWIG_fail;
46905 }
46906 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46907 return resultobj;
46908 fail:
46909 return NULL;
46910 }
46911
46912
46913 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46914 PyObject *resultobj = 0;
46915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46916 wxBitmap *arg2 = 0 ;
46917 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46918 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46919 void *argp1 = 0 ;
46920 int res1 = 0 ;
46921 void *argp2 = 0 ;
46922 int res2 = 0 ;
46923 void *argp3 = 0 ;
46924 int res3 = 0 ;
46925 PyObject * obj0 = 0 ;
46926 PyObject * obj1 = 0 ;
46927 PyObject * obj2 = 0 ;
46928 char * kwnames[] = {
46929 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46930 };
46931
46932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46934 if (!SWIG_IsOK(res1)) {
46935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46936 }
46937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46938 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46939 if (!SWIG_IsOK(res2)) {
46940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46941 }
46942 if (!argp2) {
46943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46944 }
46945 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46946 if (obj2) {
46947 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46948 if (!SWIG_IsOK(res3)) {
46949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46950 }
46951 if (!argp3) {
46952 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46953 }
46954 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46955 }
46956 {
46957 PyThreadState* __tstate = wxPyBeginAllowThreads();
46958 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46959 wxPyEndAllowThreads(__tstate);
46960 if (PyErr_Occurred()) SWIG_fail;
46961 }
46962 resultobj = SWIG_Py_Void();
46963 return resultobj;
46964 fail:
46965 return NULL;
46966 }
46967
46968
46969 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46970 PyObject *resultobj = 0;
46971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46972 wxBitmap *arg2 = 0 ;
46973 void *argp1 = 0 ;
46974 int res1 = 0 ;
46975 void *argp2 = 0 ;
46976 int res2 = 0 ;
46977 PyObject * obj0 = 0 ;
46978 PyObject * obj1 = 0 ;
46979 char * kwnames[] = {
46980 (char *) "self",(char *) "bmpDisabled", NULL
46981 };
46982
46983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46985 if (!SWIG_IsOK(res1)) {
46986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46987 }
46988 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46989 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46990 if (!SWIG_IsOK(res2)) {
46991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46992 }
46993 if (!argp2) {
46994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46995 }
46996 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46997 {
46998 PyThreadState* __tstate = wxPyBeginAllowThreads();
46999 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47000 wxPyEndAllowThreads(__tstate);
47001 if (PyErr_Occurred()) SWIG_fail;
47002 }
47003 resultobj = SWIG_Py_Void();
47004 return resultobj;
47005 fail:
47006 return NULL;
47007 }
47008
47009
47010 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47011 PyObject *resultobj = 0;
47012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47013 wxBitmap *result = 0 ;
47014 void *argp1 = 0 ;
47015 int res1 = 0 ;
47016 PyObject *swig_obj[1] ;
47017
47018 if (!args) SWIG_fail;
47019 swig_obj[0] = args;
47020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47021 if (!SWIG_IsOK(res1)) {
47022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47023 }
47024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47025 {
47026 PyThreadState* __tstate = wxPyBeginAllowThreads();
47027 {
47028 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47029 result = (wxBitmap *) &_result_ref;
47030 }
47031 wxPyEndAllowThreads(__tstate);
47032 if (PyErr_Occurred()) SWIG_fail;
47033 }
47034 {
47035 wxBitmap* resultptr = new wxBitmap(*result);
47036 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47037 }
47038 return resultobj;
47039 fail:
47040 return NULL;
47041 }
47042
47043
47044 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47045 PyObject *resultobj = 0;
47046 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47047 int arg2 ;
47048 void *argp1 = 0 ;
47049 int res1 = 0 ;
47050 int val2 ;
47051 int ecode2 = 0 ;
47052 PyObject * obj0 = 0 ;
47053 PyObject * obj1 = 0 ;
47054 char * kwnames[] = {
47055 (char *) "self",(char *) "nWidth", NULL
47056 };
47057
47058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47060 if (!SWIG_IsOK(res1)) {
47061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47062 }
47063 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47064 ecode2 = SWIG_AsVal_int(obj1, &val2);
47065 if (!SWIG_IsOK(ecode2)) {
47066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47067 }
47068 arg2 = static_cast< int >(val2);
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 (arg1)->SetMarginWidth(arg2);
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 resultobj = SWIG_Py_Void();
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47083 PyObject *resultobj = 0;
47084 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47085 int result;
47086 void *argp1 = 0 ;
47087 int res1 = 0 ;
47088 PyObject *swig_obj[1] ;
47089
47090 if (!args) SWIG_fail;
47091 swig_obj[0] = args;
47092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47093 if (!SWIG_IsOK(res1)) {
47094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47095 }
47096 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47097 {
47098 PyThreadState* __tstate = wxPyBeginAllowThreads();
47099 result = (int)(arg1)->GetMarginWidth();
47100 wxPyEndAllowThreads(__tstate);
47101 if (PyErr_Occurred()) SWIG_fail;
47102 }
47103 resultobj = SWIG_From_int(static_cast< int >(result));
47104 return resultobj;
47105 fail:
47106 return NULL;
47107 }
47108
47109
47110 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47111 PyObject *resultobj = 0;
47112 int result;
47113
47114 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47115 {
47116 PyThreadState* __tstate = wxPyBeginAllowThreads();
47117 result = (int)wxMenuItem::GetDefaultMarginWidth();
47118 wxPyEndAllowThreads(__tstate);
47119 if (PyErr_Occurred()) SWIG_fail;
47120 }
47121 resultobj = SWIG_From_int(static_cast< int >(result));
47122 return resultobj;
47123 fail:
47124 return NULL;
47125 }
47126
47127
47128 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47129 PyObject *resultobj = 0;
47130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47131 bool result;
47132 void *argp1 = 0 ;
47133 int res1 = 0 ;
47134 PyObject *swig_obj[1] ;
47135
47136 if (!args) SWIG_fail;
47137 swig_obj[0] = args;
47138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47139 if (!SWIG_IsOK(res1)) {
47140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47141 }
47142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47143 {
47144 PyThreadState* __tstate = wxPyBeginAllowThreads();
47145 result = (bool)(arg1)->IsOwnerDrawn();
47146 wxPyEndAllowThreads(__tstate);
47147 if (PyErr_Occurred()) SWIG_fail;
47148 }
47149 {
47150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47151 }
47152 return resultobj;
47153 fail:
47154 return NULL;
47155 }
47156
47157
47158 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47159 PyObject *resultobj = 0;
47160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47161 bool arg2 = (bool) true ;
47162 void *argp1 = 0 ;
47163 int res1 = 0 ;
47164 bool val2 ;
47165 int ecode2 = 0 ;
47166 PyObject * obj0 = 0 ;
47167 PyObject * obj1 = 0 ;
47168 char * kwnames[] = {
47169 (char *) "self",(char *) "ownerDrawn", NULL
47170 };
47171
47172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47174 if (!SWIG_IsOK(res1)) {
47175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47176 }
47177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47178 if (obj1) {
47179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47180 if (!SWIG_IsOK(ecode2)) {
47181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47182 }
47183 arg2 = static_cast< bool >(val2);
47184 }
47185 {
47186 PyThreadState* __tstate = wxPyBeginAllowThreads();
47187 (arg1)->SetOwnerDrawn(arg2);
47188 wxPyEndAllowThreads(__tstate);
47189 if (PyErr_Occurred()) SWIG_fail;
47190 }
47191 resultobj = SWIG_Py_Void();
47192 return resultobj;
47193 fail:
47194 return NULL;
47195 }
47196
47197
47198 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47199 PyObject *resultobj = 0;
47200 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47201 void *argp1 = 0 ;
47202 int res1 = 0 ;
47203 PyObject *swig_obj[1] ;
47204
47205 if (!args) SWIG_fail;
47206 swig_obj[0] = args;
47207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47208 if (!SWIG_IsOK(res1)) {
47209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47210 }
47211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47212 {
47213 PyThreadState* __tstate = wxPyBeginAllowThreads();
47214 (arg1)->ResetOwnerDrawn();
47215 wxPyEndAllowThreads(__tstate);
47216 if (PyErr_Occurred()) SWIG_fail;
47217 }
47218 resultobj = SWIG_Py_Void();
47219 return resultobj;
47220 fail:
47221 return NULL;
47222 }
47223
47224
47225 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47226 PyObject *obj;
47227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47228 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47229 return SWIG_Py_Void();
47230 }
47231
47232 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47233 return SWIG_Python_InitShadowInstance(args);
47234 }
47235
47236 SWIGINTERN int ControlNameStr_set(PyObject *) {
47237 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47238 return 1;
47239 }
47240
47241
47242 SWIGINTERN PyObject *ControlNameStr_get(void) {
47243 PyObject *pyobj = 0;
47244
47245 {
47246 #if wxUSE_UNICODE
47247 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47248 #else
47249 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47250 #endif
47251 }
47252 return pyobj;
47253 }
47254
47255
47256 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47257 PyObject *resultobj = 0;
47258 wxWindow *arg1 = (wxWindow *) 0 ;
47259 int arg2 = (int) -1 ;
47260 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47261 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47262 wxSize const &arg4_defvalue = wxDefaultSize ;
47263 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47264 long arg5 = (long) 0 ;
47265 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47266 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47267 wxString const &arg7_defvalue = wxPyControlNameStr ;
47268 wxString *arg7 = (wxString *) &arg7_defvalue ;
47269 wxControl *result = 0 ;
47270 void *argp1 = 0 ;
47271 int res1 = 0 ;
47272 int val2 ;
47273 int ecode2 = 0 ;
47274 wxPoint temp3 ;
47275 wxSize temp4 ;
47276 long val5 ;
47277 int ecode5 = 0 ;
47278 void *argp6 = 0 ;
47279 int res6 = 0 ;
47280 bool temp7 = false ;
47281 PyObject * obj0 = 0 ;
47282 PyObject * obj1 = 0 ;
47283 PyObject * obj2 = 0 ;
47284 PyObject * obj3 = 0 ;
47285 PyObject * obj4 = 0 ;
47286 PyObject * obj5 = 0 ;
47287 PyObject * obj6 = 0 ;
47288 char * kwnames[] = {
47289 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47290 };
47291
47292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47294 if (!SWIG_IsOK(res1)) {
47295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47296 }
47297 arg1 = reinterpret_cast< wxWindow * >(argp1);
47298 if (obj1) {
47299 ecode2 = SWIG_AsVal_int(obj1, &val2);
47300 if (!SWIG_IsOK(ecode2)) {
47301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47302 }
47303 arg2 = static_cast< int >(val2);
47304 }
47305 if (obj2) {
47306 {
47307 arg3 = &temp3;
47308 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47309 }
47310 }
47311 if (obj3) {
47312 {
47313 arg4 = &temp4;
47314 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47315 }
47316 }
47317 if (obj4) {
47318 ecode5 = SWIG_AsVal_long(obj4, &val5);
47319 if (!SWIG_IsOK(ecode5)) {
47320 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47321 }
47322 arg5 = static_cast< long >(val5);
47323 }
47324 if (obj5) {
47325 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47326 if (!SWIG_IsOK(res6)) {
47327 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47328 }
47329 if (!argp6) {
47330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47331 }
47332 arg6 = reinterpret_cast< wxValidator * >(argp6);
47333 }
47334 if (obj6) {
47335 {
47336 arg7 = wxString_in_helper(obj6);
47337 if (arg7 == NULL) SWIG_fail;
47338 temp7 = true;
47339 }
47340 }
47341 {
47342 if (!wxPyCheckForApp()) SWIG_fail;
47343 PyThreadState* __tstate = wxPyBeginAllowThreads();
47344 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47345 wxPyEndAllowThreads(__tstate);
47346 if (PyErr_Occurred()) SWIG_fail;
47347 }
47348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47349 {
47350 if (temp7)
47351 delete arg7;
47352 }
47353 return resultobj;
47354 fail:
47355 {
47356 if (temp7)
47357 delete arg7;
47358 }
47359 return NULL;
47360 }
47361
47362
47363 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47364 PyObject *resultobj = 0;
47365 wxControl *result = 0 ;
47366
47367 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47368 {
47369 if (!wxPyCheckForApp()) SWIG_fail;
47370 PyThreadState* __tstate = wxPyBeginAllowThreads();
47371 result = (wxControl *)new wxControl();
47372 wxPyEndAllowThreads(__tstate);
47373 if (PyErr_Occurred()) SWIG_fail;
47374 }
47375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47376 return resultobj;
47377 fail:
47378 return NULL;
47379 }
47380
47381
47382 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47383 PyObject *resultobj = 0;
47384 wxControl *arg1 = (wxControl *) 0 ;
47385 wxWindow *arg2 = (wxWindow *) 0 ;
47386 int arg3 = (int) -1 ;
47387 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47388 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47389 wxSize const &arg5_defvalue = wxDefaultSize ;
47390 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47391 long arg6 = (long) 0 ;
47392 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47393 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47394 wxString const &arg8_defvalue = wxPyControlNameStr ;
47395 wxString *arg8 = (wxString *) &arg8_defvalue ;
47396 bool result;
47397 void *argp1 = 0 ;
47398 int res1 = 0 ;
47399 void *argp2 = 0 ;
47400 int res2 = 0 ;
47401 int val3 ;
47402 int ecode3 = 0 ;
47403 wxPoint temp4 ;
47404 wxSize temp5 ;
47405 long val6 ;
47406 int ecode6 = 0 ;
47407 void *argp7 = 0 ;
47408 int res7 = 0 ;
47409 bool temp8 = false ;
47410 PyObject * obj0 = 0 ;
47411 PyObject * obj1 = 0 ;
47412 PyObject * obj2 = 0 ;
47413 PyObject * obj3 = 0 ;
47414 PyObject * obj4 = 0 ;
47415 PyObject * obj5 = 0 ;
47416 PyObject * obj6 = 0 ;
47417 PyObject * obj7 = 0 ;
47418 char * kwnames[] = {
47419 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47420 };
47421
47422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47424 if (!SWIG_IsOK(res1)) {
47425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47426 }
47427 arg1 = reinterpret_cast< wxControl * >(argp1);
47428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47429 if (!SWIG_IsOK(res2)) {
47430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47431 }
47432 arg2 = reinterpret_cast< wxWindow * >(argp2);
47433 if (obj2) {
47434 ecode3 = SWIG_AsVal_int(obj2, &val3);
47435 if (!SWIG_IsOK(ecode3)) {
47436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47437 }
47438 arg3 = static_cast< int >(val3);
47439 }
47440 if (obj3) {
47441 {
47442 arg4 = &temp4;
47443 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47444 }
47445 }
47446 if (obj4) {
47447 {
47448 arg5 = &temp5;
47449 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47450 }
47451 }
47452 if (obj5) {
47453 ecode6 = SWIG_AsVal_long(obj5, &val6);
47454 if (!SWIG_IsOK(ecode6)) {
47455 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47456 }
47457 arg6 = static_cast< long >(val6);
47458 }
47459 if (obj6) {
47460 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47461 if (!SWIG_IsOK(res7)) {
47462 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47463 }
47464 if (!argp7) {
47465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47466 }
47467 arg7 = reinterpret_cast< wxValidator * >(argp7);
47468 }
47469 if (obj7) {
47470 {
47471 arg8 = wxString_in_helper(obj7);
47472 if (arg8 == NULL) SWIG_fail;
47473 temp8 = true;
47474 }
47475 }
47476 {
47477 PyThreadState* __tstate = wxPyBeginAllowThreads();
47478 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47479 wxPyEndAllowThreads(__tstate);
47480 if (PyErr_Occurred()) SWIG_fail;
47481 }
47482 {
47483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47484 }
47485 {
47486 if (temp8)
47487 delete arg8;
47488 }
47489 return resultobj;
47490 fail:
47491 {
47492 if (temp8)
47493 delete arg8;
47494 }
47495 return NULL;
47496 }
47497
47498
47499 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47500 PyObject *resultobj = 0;
47501 wxControl *arg1 = (wxControl *) 0 ;
47502 int result;
47503 void *argp1 = 0 ;
47504 int res1 = 0 ;
47505 PyObject *swig_obj[1] ;
47506
47507 if (!args) SWIG_fail;
47508 swig_obj[0] = args;
47509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47510 if (!SWIG_IsOK(res1)) {
47511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47512 }
47513 arg1 = reinterpret_cast< wxControl * >(argp1);
47514 {
47515 PyThreadState* __tstate = wxPyBeginAllowThreads();
47516 result = (int)((wxControl const *)arg1)->GetAlignment();
47517 wxPyEndAllowThreads(__tstate);
47518 if (PyErr_Occurred()) SWIG_fail;
47519 }
47520 resultobj = SWIG_From_int(static_cast< int >(result));
47521 return resultobj;
47522 fail:
47523 return NULL;
47524 }
47525
47526
47527 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47528 PyObject *resultobj = 0;
47529 wxControl *arg1 = (wxControl *) 0 ;
47530 wxString result;
47531 void *argp1 = 0 ;
47532 int res1 = 0 ;
47533 PyObject *swig_obj[1] ;
47534
47535 if (!args) SWIG_fail;
47536 swig_obj[0] = args;
47537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47538 if (!SWIG_IsOK(res1)) {
47539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47540 }
47541 arg1 = reinterpret_cast< wxControl * >(argp1);
47542 {
47543 PyThreadState* __tstate = wxPyBeginAllowThreads();
47544 result = ((wxControl const *)arg1)->GetLabelText();
47545 wxPyEndAllowThreads(__tstate);
47546 if (PyErr_Occurred()) SWIG_fail;
47547 }
47548 {
47549 #if wxUSE_UNICODE
47550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47551 #else
47552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47553 #endif
47554 }
47555 return resultobj;
47556 fail:
47557 return NULL;
47558 }
47559
47560
47561 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47562 PyObject *resultobj = 0;
47563 wxControl *arg1 = (wxControl *) 0 ;
47564 wxCommandEvent *arg2 = 0 ;
47565 void *argp1 = 0 ;
47566 int res1 = 0 ;
47567 void *argp2 = 0 ;
47568 int res2 = 0 ;
47569 PyObject * obj0 = 0 ;
47570 PyObject * obj1 = 0 ;
47571 char * kwnames[] = {
47572 (char *) "self",(char *) "event", NULL
47573 };
47574
47575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47577 if (!SWIG_IsOK(res1)) {
47578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47579 }
47580 arg1 = reinterpret_cast< wxControl * >(argp1);
47581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47582 if (!SWIG_IsOK(res2)) {
47583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47584 }
47585 if (!argp2) {
47586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47587 }
47588 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47589 {
47590 PyThreadState* __tstate = wxPyBeginAllowThreads();
47591 (arg1)->Command(*arg2);
47592 wxPyEndAllowThreads(__tstate);
47593 if (PyErr_Occurred()) SWIG_fail;
47594 }
47595 resultobj = SWIG_Py_Void();
47596 return resultobj;
47597 fail:
47598 return NULL;
47599 }
47600
47601
47602 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47603 PyObject *resultobj = 0;
47604 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47605 SwigValueWrapper<wxVisualAttributes > result;
47606 int val1 ;
47607 int ecode1 = 0 ;
47608 PyObject * obj0 = 0 ;
47609 char * kwnames[] = {
47610 (char *) "variant", NULL
47611 };
47612
47613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47614 if (obj0) {
47615 ecode1 = SWIG_AsVal_int(obj0, &val1);
47616 if (!SWIG_IsOK(ecode1)) {
47617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47618 }
47619 arg1 = static_cast< wxWindowVariant >(val1);
47620 }
47621 {
47622 if (!wxPyCheckForApp()) SWIG_fail;
47623 PyThreadState* __tstate = wxPyBeginAllowThreads();
47624 result = wxControl::GetClassDefaultAttributes(arg1);
47625 wxPyEndAllowThreads(__tstate);
47626 if (PyErr_Occurred()) SWIG_fail;
47627 }
47628 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47629 return resultobj;
47630 fail:
47631 return NULL;
47632 }
47633
47634
47635 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47636 PyObject *obj;
47637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47638 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47639 return SWIG_Py_Void();
47640 }
47641
47642 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47643 return SWIG_Python_InitShadowInstance(args);
47644 }
47645
47646 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47647 PyObject *resultobj = 0;
47648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47649 wxString *arg2 = 0 ;
47650 PyObject *arg3 = (PyObject *) NULL ;
47651 int result;
47652 void *argp1 = 0 ;
47653 int res1 = 0 ;
47654 bool temp2 = false ;
47655 PyObject * obj0 = 0 ;
47656 PyObject * obj1 = 0 ;
47657 PyObject * obj2 = 0 ;
47658 char * kwnames[] = {
47659 (char *) "self",(char *) "item",(char *) "clientData", NULL
47660 };
47661
47662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47664 if (!SWIG_IsOK(res1)) {
47665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47666 }
47667 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47668 {
47669 arg2 = wxString_in_helper(obj1);
47670 if (arg2 == NULL) SWIG_fail;
47671 temp2 = true;
47672 }
47673 if (obj2) {
47674 arg3 = obj2;
47675 }
47676 {
47677 PyThreadState* __tstate = wxPyBeginAllowThreads();
47678 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47679 wxPyEndAllowThreads(__tstate);
47680 if (PyErr_Occurred()) SWIG_fail;
47681 }
47682 resultobj = SWIG_From_int(static_cast< int >(result));
47683 {
47684 if (temp2)
47685 delete arg2;
47686 }
47687 return resultobj;
47688 fail:
47689 {
47690 if (temp2)
47691 delete arg2;
47692 }
47693 return NULL;
47694 }
47695
47696
47697 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47698 PyObject *resultobj = 0;
47699 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47700 wxArrayString *arg2 = 0 ;
47701 void *argp1 = 0 ;
47702 int res1 = 0 ;
47703 bool temp2 = false ;
47704 PyObject * obj0 = 0 ;
47705 PyObject * obj1 = 0 ;
47706 char * kwnames[] = {
47707 (char *) "self",(char *) "strings", NULL
47708 };
47709
47710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47712 if (!SWIG_IsOK(res1)) {
47713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47714 }
47715 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47716 {
47717 if (! PySequence_Check(obj1)) {
47718 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47719 SWIG_fail;
47720 }
47721 arg2 = new wxArrayString;
47722 temp2 = true;
47723 int i, len=PySequence_Length(obj1);
47724 for (i=0; i<len; i++) {
47725 PyObject* item = PySequence_GetItem(obj1, i);
47726 wxString* s = wxString_in_helper(item);
47727 if (PyErr_Occurred()) SWIG_fail;
47728 arg2->Add(*s);
47729 delete s;
47730 Py_DECREF(item);
47731 }
47732 }
47733 {
47734 PyThreadState* __tstate = wxPyBeginAllowThreads();
47735 (arg1)->Append((wxArrayString const &)*arg2);
47736 wxPyEndAllowThreads(__tstate);
47737 if (PyErr_Occurred()) SWIG_fail;
47738 }
47739 resultobj = SWIG_Py_Void();
47740 {
47741 if (temp2) delete arg2;
47742 }
47743 return resultobj;
47744 fail:
47745 {
47746 if (temp2) delete arg2;
47747 }
47748 return NULL;
47749 }
47750
47751
47752 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47753 PyObject *resultobj = 0;
47754 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47755 wxString *arg2 = 0 ;
47756 unsigned int arg3 ;
47757 PyObject *arg4 = (PyObject *) NULL ;
47758 int result;
47759 void *argp1 = 0 ;
47760 int res1 = 0 ;
47761 bool temp2 = false ;
47762 unsigned int val3 ;
47763 int ecode3 = 0 ;
47764 PyObject * obj0 = 0 ;
47765 PyObject * obj1 = 0 ;
47766 PyObject * obj2 = 0 ;
47767 PyObject * obj3 = 0 ;
47768 char * kwnames[] = {
47769 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47770 };
47771
47772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47774 if (!SWIG_IsOK(res1)) {
47775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47776 }
47777 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47778 {
47779 arg2 = wxString_in_helper(obj1);
47780 if (arg2 == NULL) SWIG_fail;
47781 temp2 = true;
47782 }
47783 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47784 if (!SWIG_IsOK(ecode3)) {
47785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47786 }
47787 arg3 = static_cast< unsigned int >(val3);
47788 if (obj3) {
47789 arg4 = obj3;
47790 }
47791 {
47792 PyThreadState* __tstate = wxPyBeginAllowThreads();
47793 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47794 wxPyEndAllowThreads(__tstate);
47795 if (PyErr_Occurred()) SWIG_fail;
47796 }
47797 resultobj = SWIG_From_int(static_cast< int >(result));
47798 {
47799 if (temp2)
47800 delete arg2;
47801 }
47802 return resultobj;
47803 fail:
47804 {
47805 if (temp2)
47806 delete arg2;
47807 }
47808 return NULL;
47809 }
47810
47811
47812 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47813 PyObject *resultobj = 0;
47814 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47815 void *argp1 = 0 ;
47816 int res1 = 0 ;
47817 PyObject *swig_obj[1] ;
47818
47819 if (!args) SWIG_fail;
47820 swig_obj[0] = args;
47821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47822 if (!SWIG_IsOK(res1)) {
47823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47824 }
47825 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47826 {
47827 PyThreadState* __tstate = wxPyBeginAllowThreads();
47828 (arg1)->Clear();
47829 wxPyEndAllowThreads(__tstate);
47830 if (PyErr_Occurred()) SWIG_fail;
47831 }
47832 resultobj = SWIG_Py_Void();
47833 return resultobj;
47834 fail:
47835 return NULL;
47836 }
47837
47838
47839 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47840 PyObject *resultobj = 0;
47841 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47842 unsigned int arg2 ;
47843 void *argp1 = 0 ;
47844 int res1 = 0 ;
47845 unsigned int val2 ;
47846 int ecode2 = 0 ;
47847 PyObject * obj0 = 0 ;
47848 PyObject * obj1 = 0 ;
47849 char * kwnames[] = {
47850 (char *) "self",(char *) "n", NULL
47851 };
47852
47853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47855 if (!SWIG_IsOK(res1)) {
47856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47857 }
47858 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47859 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47860 if (!SWIG_IsOK(ecode2)) {
47861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47862 }
47863 arg2 = static_cast< unsigned int >(val2);
47864 {
47865 PyThreadState* __tstate = wxPyBeginAllowThreads();
47866 (arg1)->Delete(arg2);
47867 wxPyEndAllowThreads(__tstate);
47868 if (PyErr_Occurred()) SWIG_fail;
47869 }
47870 resultobj = SWIG_Py_Void();
47871 return resultobj;
47872 fail:
47873 return NULL;
47874 }
47875
47876
47877 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47878 PyObject *resultobj = 0;
47879 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47880 unsigned int arg2 ;
47881 PyObject *result = 0 ;
47882 void *argp1 = 0 ;
47883 int res1 = 0 ;
47884 unsigned int val2 ;
47885 int ecode2 = 0 ;
47886 PyObject * obj0 = 0 ;
47887 PyObject * obj1 = 0 ;
47888 char * kwnames[] = {
47889 (char *) "self",(char *) "n", NULL
47890 };
47891
47892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47894 if (!SWIG_IsOK(res1)) {
47895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47896 }
47897 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47898 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47899 if (!SWIG_IsOK(ecode2)) {
47900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47901 }
47902 arg2 = static_cast< unsigned int >(val2);
47903 {
47904 PyThreadState* __tstate = wxPyBeginAllowThreads();
47905 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47906 wxPyEndAllowThreads(__tstate);
47907 if (PyErr_Occurred()) SWIG_fail;
47908 }
47909 resultobj = result;
47910 return resultobj;
47911 fail:
47912 return NULL;
47913 }
47914
47915
47916 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47917 PyObject *resultobj = 0;
47918 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47919 unsigned int arg2 ;
47920 PyObject *arg3 = (PyObject *) 0 ;
47921 void *argp1 = 0 ;
47922 int res1 = 0 ;
47923 unsigned int val2 ;
47924 int ecode2 = 0 ;
47925 PyObject * obj0 = 0 ;
47926 PyObject * obj1 = 0 ;
47927 PyObject * obj2 = 0 ;
47928 char * kwnames[] = {
47929 (char *) "self",(char *) "n",(char *) "clientData", NULL
47930 };
47931
47932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47934 if (!SWIG_IsOK(res1)) {
47935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47936 }
47937 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47938 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47939 if (!SWIG_IsOK(ecode2)) {
47940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47941 }
47942 arg2 = static_cast< unsigned int >(val2);
47943 arg3 = obj2;
47944 {
47945 PyThreadState* __tstate = wxPyBeginAllowThreads();
47946 wxItemContainer_SetClientData(arg1,arg2,arg3);
47947 wxPyEndAllowThreads(__tstate);
47948 if (PyErr_Occurred()) SWIG_fail;
47949 }
47950 resultobj = SWIG_Py_Void();
47951 return resultobj;
47952 fail:
47953 return NULL;
47954 }
47955
47956
47957 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47958 PyObject *resultobj = 0;
47959 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47960 unsigned int result;
47961 void *argp1 = 0 ;
47962 int res1 = 0 ;
47963 PyObject *swig_obj[1] ;
47964
47965 if (!args) SWIG_fail;
47966 swig_obj[0] = args;
47967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47968 if (!SWIG_IsOK(res1)) {
47969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47970 }
47971 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47972 {
47973 PyThreadState* __tstate = wxPyBeginAllowThreads();
47974 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47975 wxPyEndAllowThreads(__tstate);
47976 if (PyErr_Occurred()) SWIG_fail;
47977 }
47978 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47979 return resultobj;
47980 fail:
47981 return NULL;
47982 }
47983
47984
47985 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47986 PyObject *resultobj = 0;
47987 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47988 bool result;
47989 void *argp1 = 0 ;
47990 int res1 = 0 ;
47991 PyObject *swig_obj[1] ;
47992
47993 if (!args) SWIG_fail;
47994 swig_obj[0] = args;
47995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47996 if (!SWIG_IsOK(res1)) {
47997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47998 }
47999 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 {
48007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48008 }
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48016 PyObject *resultobj = 0;
48017 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48018 unsigned int arg2 ;
48019 wxString result;
48020 void *argp1 = 0 ;
48021 int res1 = 0 ;
48022 unsigned int val2 ;
48023 int ecode2 = 0 ;
48024 PyObject * obj0 = 0 ;
48025 PyObject * obj1 = 0 ;
48026 char * kwnames[] = {
48027 (char *) "self",(char *) "n", NULL
48028 };
48029
48030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48032 if (!SWIG_IsOK(res1)) {
48033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48034 }
48035 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48036 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48037 if (!SWIG_IsOK(ecode2)) {
48038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48039 }
48040 arg2 = static_cast< unsigned int >(val2);
48041 {
48042 PyThreadState* __tstate = wxPyBeginAllowThreads();
48043 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48044 wxPyEndAllowThreads(__tstate);
48045 if (PyErr_Occurred()) SWIG_fail;
48046 }
48047 {
48048 #if wxUSE_UNICODE
48049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48050 #else
48051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48052 #endif
48053 }
48054 return resultobj;
48055 fail:
48056 return NULL;
48057 }
48058
48059
48060 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48061 PyObject *resultobj = 0;
48062 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48063 wxArrayString result;
48064 void *argp1 = 0 ;
48065 int res1 = 0 ;
48066 PyObject *swig_obj[1] ;
48067
48068 if (!args) SWIG_fail;
48069 swig_obj[0] = args;
48070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48071 if (!SWIG_IsOK(res1)) {
48072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48073 }
48074 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48075 {
48076 PyThreadState* __tstate = wxPyBeginAllowThreads();
48077 result = ((wxItemContainer const *)arg1)->GetStrings();
48078 wxPyEndAllowThreads(__tstate);
48079 if (PyErr_Occurred()) SWIG_fail;
48080 }
48081 {
48082 resultobj = wxArrayString2PyList_helper(result);
48083 }
48084 return resultobj;
48085 fail:
48086 return NULL;
48087 }
48088
48089
48090 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48091 PyObject *resultobj = 0;
48092 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48093 unsigned int arg2 ;
48094 wxString *arg3 = 0 ;
48095 void *argp1 = 0 ;
48096 int res1 = 0 ;
48097 unsigned int val2 ;
48098 int ecode2 = 0 ;
48099 bool temp3 = false ;
48100 PyObject * obj0 = 0 ;
48101 PyObject * obj1 = 0 ;
48102 PyObject * obj2 = 0 ;
48103 char * kwnames[] = {
48104 (char *) "self",(char *) "n",(char *) "s", NULL
48105 };
48106
48107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48109 if (!SWIG_IsOK(res1)) {
48110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48111 }
48112 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48113 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48114 if (!SWIG_IsOK(ecode2)) {
48115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48116 }
48117 arg2 = static_cast< unsigned int >(val2);
48118 {
48119 arg3 = wxString_in_helper(obj2);
48120 if (arg3 == NULL) SWIG_fail;
48121 temp3 = true;
48122 }
48123 {
48124 PyThreadState* __tstate = wxPyBeginAllowThreads();
48125 (arg1)->SetString(arg2,(wxString const &)*arg3);
48126 wxPyEndAllowThreads(__tstate);
48127 if (PyErr_Occurred()) SWIG_fail;
48128 }
48129 resultobj = SWIG_Py_Void();
48130 {
48131 if (temp3)
48132 delete arg3;
48133 }
48134 return resultobj;
48135 fail:
48136 {
48137 if (temp3)
48138 delete arg3;
48139 }
48140 return NULL;
48141 }
48142
48143
48144 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48145 PyObject *resultobj = 0;
48146 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48147 wxString *arg2 = 0 ;
48148 int result;
48149 void *argp1 = 0 ;
48150 int res1 = 0 ;
48151 bool temp2 = false ;
48152 PyObject * obj0 = 0 ;
48153 PyObject * obj1 = 0 ;
48154 char * kwnames[] = {
48155 (char *) "self",(char *) "s", NULL
48156 };
48157
48158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48160 if (!SWIG_IsOK(res1)) {
48161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48162 }
48163 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48164 {
48165 arg2 = wxString_in_helper(obj1);
48166 if (arg2 == NULL) SWIG_fail;
48167 temp2 = true;
48168 }
48169 {
48170 PyThreadState* __tstate = wxPyBeginAllowThreads();
48171 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48172 wxPyEndAllowThreads(__tstate);
48173 if (PyErr_Occurred()) SWIG_fail;
48174 }
48175 resultobj = SWIG_From_int(static_cast< int >(result));
48176 {
48177 if (temp2)
48178 delete arg2;
48179 }
48180 return resultobj;
48181 fail:
48182 {
48183 if (temp2)
48184 delete arg2;
48185 }
48186 return NULL;
48187 }
48188
48189
48190 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48191 PyObject *resultobj = 0;
48192 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48193 int arg2 ;
48194 void *argp1 = 0 ;
48195 int res1 = 0 ;
48196 int val2 ;
48197 int ecode2 = 0 ;
48198 PyObject * obj0 = 0 ;
48199 PyObject * obj1 = 0 ;
48200 char * kwnames[] = {
48201 (char *) "self",(char *) "n", NULL
48202 };
48203
48204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48206 if (!SWIG_IsOK(res1)) {
48207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48208 }
48209 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48210 ecode2 = SWIG_AsVal_int(obj1, &val2);
48211 if (!SWIG_IsOK(ecode2)) {
48212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48213 }
48214 arg2 = static_cast< int >(val2);
48215 {
48216 PyThreadState* __tstate = wxPyBeginAllowThreads();
48217 (arg1)->SetSelection(arg2);
48218 wxPyEndAllowThreads(__tstate);
48219 if (PyErr_Occurred()) SWIG_fail;
48220 }
48221 resultobj = SWIG_Py_Void();
48222 return resultobj;
48223 fail:
48224 return NULL;
48225 }
48226
48227
48228 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48229 PyObject *resultobj = 0;
48230 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48231 int result;
48232 void *argp1 = 0 ;
48233 int res1 = 0 ;
48234 PyObject *swig_obj[1] ;
48235
48236 if (!args) SWIG_fail;
48237 swig_obj[0] = args;
48238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48239 if (!SWIG_IsOK(res1)) {
48240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48241 }
48242 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48243 {
48244 PyThreadState* __tstate = wxPyBeginAllowThreads();
48245 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48246 wxPyEndAllowThreads(__tstate);
48247 if (PyErr_Occurred()) SWIG_fail;
48248 }
48249 resultobj = SWIG_From_int(static_cast< int >(result));
48250 return resultobj;
48251 fail:
48252 return NULL;
48253 }
48254
48255
48256 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48257 PyObject *resultobj = 0;
48258 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48259 wxString *arg2 = 0 ;
48260 bool result;
48261 void *argp1 = 0 ;
48262 int res1 = 0 ;
48263 bool temp2 = false ;
48264 PyObject * obj0 = 0 ;
48265 PyObject * obj1 = 0 ;
48266 char * kwnames[] = {
48267 (char *) "self",(char *) "s", NULL
48268 };
48269
48270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48272 if (!SWIG_IsOK(res1)) {
48273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48274 }
48275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48276 {
48277 arg2 = wxString_in_helper(obj1);
48278 if (arg2 == NULL) SWIG_fail;
48279 temp2 = true;
48280 }
48281 {
48282 PyThreadState* __tstate = wxPyBeginAllowThreads();
48283 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48284 wxPyEndAllowThreads(__tstate);
48285 if (PyErr_Occurred()) SWIG_fail;
48286 }
48287 {
48288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48289 }
48290 {
48291 if (temp2)
48292 delete arg2;
48293 }
48294 return resultobj;
48295 fail:
48296 {
48297 if (temp2)
48298 delete arg2;
48299 }
48300 return NULL;
48301 }
48302
48303
48304 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48305 PyObject *resultobj = 0;
48306 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48307 wxString result;
48308 void *argp1 = 0 ;
48309 int res1 = 0 ;
48310 PyObject *swig_obj[1] ;
48311
48312 if (!args) SWIG_fail;
48313 swig_obj[0] = args;
48314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48315 if (!SWIG_IsOK(res1)) {
48316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48317 }
48318 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48319 {
48320 PyThreadState* __tstate = wxPyBeginAllowThreads();
48321 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48322 wxPyEndAllowThreads(__tstate);
48323 if (PyErr_Occurred()) SWIG_fail;
48324 }
48325 {
48326 #if wxUSE_UNICODE
48327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48328 #else
48329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48330 #endif
48331 }
48332 return resultobj;
48333 fail:
48334 return NULL;
48335 }
48336
48337
48338 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48339 PyObject *resultobj = 0;
48340 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48341 int arg2 ;
48342 void *argp1 = 0 ;
48343 int res1 = 0 ;
48344 int val2 ;
48345 int ecode2 = 0 ;
48346 PyObject * obj0 = 0 ;
48347 PyObject * obj1 = 0 ;
48348 char * kwnames[] = {
48349 (char *) "self",(char *) "n", NULL
48350 };
48351
48352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48354 if (!SWIG_IsOK(res1)) {
48355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48356 }
48357 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48358 ecode2 = SWIG_AsVal_int(obj1, &val2);
48359 if (!SWIG_IsOK(ecode2)) {
48360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48361 }
48362 arg2 = static_cast< int >(val2);
48363 {
48364 PyThreadState* __tstate = wxPyBeginAllowThreads();
48365 (arg1)->Select(arg2);
48366 wxPyEndAllowThreads(__tstate);
48367 if (PyErr_Occurred()) SWIG_fail;
48368 }
48369 resultobj = SWIG_Py_Void();
48370 return resultobj;
48371 fail:
48372 return NULL;
48373 }
48374
48375
48376 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48377 PyObject *obj;
48378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48379 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48380 return SWIG_Py_Void();
48381 }
48382
48383 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48384 PyObject *obj;
48385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48386 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48387 return SWIG_Py_Void();
48388 }
48389
48390 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48391 PyObject *resultobj = 0;
48392 wxSizerItem *result = 0 ;
48393
48394 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48395 {
48396 PyThreadState* __tstate = wxPyBeginAllowThreads();
48397 result = (wxSizerItem *)new wxSizerItem();
48398 wxPyEndAllowThreads(__tstate);
48399 if (PyErr_Occurred()) SWIG_fail;
48400 }
48401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48402 return resultobj;
48403 fail:
48404 return NULL;
48405 }
48406
48407
48408 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48409 PyObject *resultobj = 0;
48410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48411 void *argp1 = 0 ;
48412 int res1 = 0 ;
48413 PyObject *swig_obj[1] ;
48414
48415 if (!args) SWIG_fail;
48416 swig_obj[0] = args;
48417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48418 if (!SWIG_IsOK(res1)) {
48419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48420 }
48421 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48422 {
48423 PyThreadState* __tstate = wxPyBeginAllowThreads();
48424 delete arg1;
48425
48426 wxPyEndAllowThreads(__tstate);
48427 if (PyErr_Occurred()) SWIG_fail;
48428 }
48429 resultobj = SWIG_Py_Void();
48430 return resultobj;
48431 fail:
48432 return NULL;
48433 }
48434
48435
48436 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48437 PyObject *resultobj = 0;
48438 wxWindow *arg1 = (wxWindow *) 0 ;
48439 int arg2 ;
48440 int arg3 ;
48441 int arg4 ;
48442 PyObject *arg5 = (PyObject *) NULL ;
48443 wxSizerItem *result = 0 ;
48444 void *argp1 = 0 ;
48445 int res1 = 0 ;
48446 int val2 ;
48447 int ecode2 = 0 ;
48448 int val3 ;
48449 int ecode3 = 0 ;
48450 int val4 ;
48451 int ecode4 = 0 ;
48452 PyObject * obj0 = 0 ;
48453 PyObject * obj1 = 0 ;
48454 PyObject * obj2 = 0 ;
48455 PyObject * obj3 = 0 ;
48456 PyObject * obj4 = 0 ;
48457 char * kwnames[] = {
48458 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48459 };
48460
48461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48463 if (!SWIG_IsOK(res1)) {
48464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48465 }
48466 arg1 = reinterpret_cast< wxWindow * >(argp1);
48467 ecode2 = SWIG_AsVal_int(obj1, &val2);
48468 if (!SWIG_IsOK(ecode2)) {
48469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48470 }
48471 arg2 = static_cast< int >(val2);
48472 ecode3 = SWIG_AsVal_int(obj2, &val3);
48473 if (!SWIG_IsOK(ecode3)) {
48474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48475 }
48476 arg3 = static_cast< int >(val3);
48477 ecode4 = SWIG_AsVal_int(obj3, &val4);
48478 if (!SWIG_IsOK(ecode4)) {
48479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48480 }
48481 arg4 = static_cast< int >(val4);
48482 if (obj4) {
48483 arg5 = obj4;
48484 }
48485 {
48486 PyThreadState* __tstate = wxPyBeginAllowThreads();
48487 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48488 wxPyEndAllowThreads(__tstate);
48489 if (PyErr_Occurred()) SWIG_fail;
48490 }
48491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48492 return resultobj;
48493 fail:
48494 return NULL;
48495 }
48496
48497
48498 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48499 PyObject *resultobj = 0;
48500 int arg1 ;
48501 int arg2 ;
48502 int arg3 ;
48503 int arg4 ;
48504 int arg5 ;
48505 PyObject *arg6 = (PyObject *) NULL ;
48506 wxSizerItem *result = 0 ;
48507 int val1 ;
48508 int ecode1 = 0 ;
48509 int val2 ;
48510 int ecode2 = 0 ;
48511 int val3 ;
48512 int ecode3 = 0 ;
48513 int val4 ;
48514 int ecode4 = 0 ;
48515 int val5 ;
48516 int ecode5 = 0 ;
48517 PyObject * obj0 = 0 ;
48518 PyObject * obj1 = 0 ;
48519 PyObject * obj2 = 0 ;
48520 PyObject * obj3 = 0 ;
48521 PyObject * obj4 = 0 ;
48522 PyObject * obj5 = 0 ;
48523 char * kwnames[] = {
48524 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48525 };
48526
48527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48528 ecode1 = SWIG_AsVal_int(obj0, &val1);
48529 if (!SWIG_IsOK(ecode1)) {
48530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48531 }
48532 arg1 = static_cast< int >(val1);
48533 ecode2 = SWIG_AsVal_int(obj1, &val2);
48534 if (!SWIG_IsOK(ecode2)) {
48535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48536 }
48537 arg2 = static_cast< int >(val2);
48538 ecode3 = SWIG_AsVal_int(obj2, &val3);
48539 if (!SWIG_IsOK(ecode3)) {
48540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48541 }
48542 arg3 = static_cast< int >(val3);
48543 ecode4 = SWIG_AsVal_int(obj3, &val4);
48544 if (!SWIG_IsOK(ecode4)) {
48545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48546 }
48547 arg4 = static_cast< int >(val4);
48548 ecode5 = SWIG_AsVal_int(obj4, &val5);
48549 if (!SWIG_IsOK(ecode5)) {
48550 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48551 }
48552 arg5 = static_cast< int >(val5);
48553 if (obj5) {
48554 arg6 = obj5;
48555 }
48556 {
48557 PyThreadState* __tstate = wxPyBeginAllowThreads();
48558 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48559 wxPyEndAllowThreads(__tstate);
48560 if (PyErr_Occurred()) SWIG_fail;
48561 }
48562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48563 return resultobj;
48564 fail:
48565 return NULL;
48566 }
48567
48568
48569 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48570 PyObject *resultobj = 0;
48571 wxSizer *arg1 = (wxSizer *) 0 ;
48572 int arg2 ;
48573 int arg3 ;
48574 int arg4 ;
48575 PyObject *arg5 = (PyObject *) NULL ;
48576 wxSizerItem *result = 0 ;
48577 int res1 = 0 ;
48578 int val2 ;
48579 int ecode2 = 0 ;
48580 int val3 ;
48581 int ecode3 = 0 ;
48582 int val4 ;
48583 int ecode4 = 0 ;
48584 PyObject * obj0 = 0 ;
48585 PyObject * obj1 = 0 ;
48586 PyObject * obj2 = 0 ;
48587 PyObject * obj3 = 0 ;
48588 PyObject * obj4 = 0 ;
48589 char * kwnames[] = {
48590 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48591 };
48592
48593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48594 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48595 if (!SWIG_IsOK(res1)) {
48596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48597 }
48598 ecode2 = SWIG_AsVal_int(obj1, &val2);
48599 if (!SWIG_IsOK(ecode2)) {
48600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48601 }
48602 arg2 = static_cast< int >(val2);
48603 ecode3 = SWIG_AsVal_int(obj2, &val3);
48604 if (!SWIG_IsOK(ecode3)) {
48605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48606 }
48607 arg3 = static_cast< int >(val3);
48608 ecode4 = SWIG_AsVal_int(obj3, &val4);
48609 if (!SWIG_IsOK(ecode4)) {
48610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48611 }
48612 arg4 = static_cast< int >(val4);
48613 if (obj4) {
48614 arg5 = obj4;
48615 }
48616 {
48617 PyThreadState* __tstate = wxPyBeginAllowThreads();
48618 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48619 wxPyEndAllowThreads(__tstate);
48620 if (PyErr_Occurred()) SWIG_fail;
48621 }
48622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48623 return resultobj;
48624 fail:
48625 return NULL;
48626 }
48627
48628
48629 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48630 PyObject *resultobj = 0;
48631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48632 void *argp1 = 0 ;
48633 int res1 = 0 ;
48634 PyObject *swig_obj[1] ;
48635
48636 if (!args) SWIG_fail;
48637 swig_obj[0] = args;
48638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48639 if (!SWIG_IsOK(res1)) {
48640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48641 }
48642 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48643 {
48644 PyThreadState* __tstate = wxPyBeginAllowThreads();
48645 (arg1)->DeleteWindows();
48646 wxPyEndAllowThreads(__tstate);
48647 if (PyErr_Occurred()) SWIG_fail;
48648 }
48649 resultobj = SWIG_Py_Void();
48650 return resultobj;
48651 fail:
48652 return NULL;
48653 }
48654
48655
48656 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48657 PyObject *resultobj = 0;
48658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48659 void *argp1 = 0 ;
48660 int res1 = 0 ;
48661 PyObject *swig_obj[1] ;
48662
48663 if (!args) SWIG_fail;
48664 swig_obj[0] = args;
48665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48666 if (!SWIG_IsOK(res1)) {
48667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48668 }
48669 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48670 {
48671 PyThreadState* __tstate = wxPyBeginAllowThreads();
48672 (arg1)->DetachSizer();
48673 wxPyEndAllowThreads(__tstate);
48674 if (PyErr_Occurred()) SWIG_fail;
48675 }
48676 resultobj = SWIG_Py_Void();
48677 return resultobj;
48678 fail:
48679 return NULL;
48680 }
48681
48682
48683 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48684 PyObject *resultobj = 0;
48685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48686 wxSize result;
48687 void *argp1 = 0 ;
48688 int res1 = 0 ;
48689 PyObject *swig_obj[1] ;
48690
48691 if (!args) SWIG_fail;
48692 swig_obj[0] = args;
48693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48694 if (!SWIG_IsOK(res1)) {
48695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48696 }
48697 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48698 {
48699 PyThreadState* __tstate = wxPyBeginAllowThreads();
48700 result = (arg1)->GetSize();
48701 wxPyEndAllowThreads(__tstate);
48702 if (PyErr_Occurred()) SWIG_fail;
48703 }
48704 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48705 return resultobj;
48706 fail:
48707 return NULL;
48708 }
48709
48710
48711 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48712 PyObject *resultobj = 0;
48713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48714 wxSize result;
48715 void *argp1 = 0 ;
48716 int res1 = 0 ;
48717 PyObject *swig_obj[1] ;
48718
48719 if (!args) SWIG_fail;
48720 swig_obj[0] = args;
48721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48722 if (!SWIG_IsOK(res1)) {
48723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48724 }
48725 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48726 {
48727 PyThreadState* __tstate = wxPyBeginAllowThreads();
48728 result = (arg1)->CalcMin();
48729 wxPyEndAllowThreads(__tstate);
48730 if (PyErr_Occurred()) SWIG_fail;
48731 }
48732 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48733 return resultobj;
48734 fail:
48735 return NULL;
48736 }
48737
48738
48739 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48740 PyObject *resultobj = 0;
48741 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48742 wxPoint *arg2 = 0 ;
48743 wxSize *arg3 = 0 ;
48744 void *argp1 = 0 ;
48745 int res1 = 0 ;
48746 wxPoint temp2 ;
48747 wxSize temp3 ;
48748 PyObject * obj0 = 0 ;
48749 PyObject * obj1 = 0 ;
48750 PyObject * obj2 = 0 ;
48751 char * kwnames[] = {
48752 (char *) "self",(char *) "pos",(char *) "size", NULL
48753 };
48754
48755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48757 if (!SWIG_IsOK(res1)) {
48758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48759 }
48760 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48761 {
48762 arg2 = &temp2;
48763 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48764 }
48765 {
48766 arg3 = &temp3;
48767 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48768 }
48769 {
48770 PyThreadState* __tstate = wxPyBeginAllowThreads();
48771 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48772 wxPyEndAllowThreads(__tstate);
48773 if (PyErr_Occurred()) SWIG_fail;
48774 }
48775 resultobj = SWIG_Py_Void();
48776 return resultobj;
48777 fail:
48778 return NULL;
48779 }
48780
48781
48782 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48783 PyObject *resultobj = 0;
48784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48785 wxSize result;
48786 void *argp1 = 0 ;
48787 int res1 = 0 ;
48788 PyObject *swig_obj[1] ;
48789
48790 if (!args) SWIG_fail;
48791 swig_obj[0] = args;
48792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48793 if (!SWIG_IsOK(res1)) {
48794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48795 }
48796 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48797 {
48798 PyThreadState* __tstate = wxPyBeginAllowThreads();
48799 result = (arg1)->GetMinSize();
48800 wxPyEndAllowThreads(__tstate);
48801 if (PyErr_Occurred()) SWIG_fail;
48802 }
48803 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48804 return resultobj;
48805 fail:
48806 return NULL;
48807 }
48808
48809
48810 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48811 PyObject *resultobj = 0;
48812 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48813 wxSize result;
48814 void *argp1 = 0 ;
48815 int res1 = 0 ;
48816 PyObject *swig_obj[1] ;
48817
48818 if (!args) SWIG_fail;
48819 swig_obj[0] = args;
48820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48821 if (!SWIG_IsOK(res1)) {
48822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48823 }
48824 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48825 {
48826 PyThreadState* __tstate = wxPyBeginAllowThreads();
48827 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48828 wxPyEndAllowThreads(__tstate);
48829 if (PyErr_Occurred()) SWIG_fail;
48830 }
48831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48832 return resultobj;
48833 fail:
48834 return NULL;
48835 }
48836
48837
48838 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48839 PyObject *resultobj = 0;
48840 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48841 int arg2 ;
48842 int arg3 ;
48843 void *argp1 = 0 ;
48844 int res1 = 0 ;
48845 int val2 ;
48846 int ecode2 = 0 ;
48847 int val3 ;
48848 int ecode3 = 0 ;
48849 PyObject * obj0 = 0 ;
48850 PyObject * obj1 = 0 ;
48851 PyObject * obj2 = 0 ;
48852 char * kwnames[] = {
48853 (char *) "self",(char *) "x",(char *) "y", NULL
48854 };
48855
48856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48858 if (!SWIG_IsOK(res1)) {
48859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48860 }
48861 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48862 ecode2 = SWIG_AsVal_int(obj1, &val2);
48863 if (!SWIG_IsOK(ecode2)) {
48864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48865 }
48866 arg2 = static_cast< int >(val2);
48867 ecode3 = SWIG_AsVal_int(obj2, &val3);
48868 if (!SWIG_IsOK(ecode3)) {
48869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48870 }
48871 arg3 = static_cast< int >(val3);
48872 {
48873 PyThreadState* __tstate = wxPyBeginAllowThreads();
48874 (arg1)->SetInitSize(arg2,arg3);
48875 wxPyEndAllowThreads(__tstate);
48876 if (PyErr_Occurred()) SWIG_fail;
48877 }
48878 resultobj = SWIG_Py_Void();
48879 return resultobj;
48880 fail:
48881 return NULL;
48882 }
48883
48884
48885 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48886 PyObject *resultobj = 0;
48887 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48888 int arg2 ;
48889 int arg3 ;
48890 void *argp1 = 0 ;
48891 int res1 = 0 ;
48892 int val2 ;
48893 int ecode2 = 0 ;
48894 int val3 ;
48895 int ecode3 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 PyObject * obj2 = 0 ;
48899 char * kwnames[] = {
48900 (char *) "self",(char *) "width",(char *) "height", NULL
48901 };
48902
48903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48905 if (!SWIG_IsOK(res1)) {
48906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48907 }
48908 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48909 ecode2 = SWIG_AsVal_int(obj1, &val2);
48910 if (!SWIG_IsOK(ecode2)) {
48911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48912 }
48913 arg2 = static_cast< int >(val2);
48914 ecode3 = SWIG_AsVal_int(obj2, &val3);
48915 if (!SWIG_IsOK(ecode3)) {
48916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48917 }
48918 arg3 = static_cast< int >(val3);
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 (arg1)->SetRatio(arg2,arg3);
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_Py_Void();
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48933 PyObject *resultobj = 0;
48934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48935 wxSize *arg2 = 0 ;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 wxSize temp2 ;
48939 PyObject * obj0 = 0 ;
48940 PyObject * obj1 = 0 ;
48941 char * kwnames[] = {
48942 (char *) "self",(char *) "size", NULL
48943 };
48944
48945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48947 if (!SWIG_IsOK(res1)) {
48948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48949 }
48950 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48951 {
48952 arg2 = &temp2;
48953 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48954 }
48955 {
48956 PyThreadState* __tstate = wxPyBeginAllowThreads();
48957 (arg1)->SetRatio((wxSize const &)*arg2);
48958 wxPyEndAllowThreads(__tstate);
48959 if (PyErr_Occurred()) SWIG_fail;
48960 }
48961 resultobj = SWIG_Py_Void();
48962 return resultobj;
48963 fail:
48964 return NULL;
48965 }
48966
48967
48968 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48969 PyObject *resultobj = 0;
48970 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48971 float arg2 ;
48972 void *argp1 = 0 ;
48973 int res1 = 0 ;
48974 float val2 ;
48975 int ecode2 = 0 ;
48976 PyObject * obj0 = 0 ;
48977 PyObject * obj1 = 0 ;
48978 char * kwnames[] = {
48979 (char *) "self",(char *) "ratio", NULL
48980 };
48981
48982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48984 if (!SWIG_IsOK(res1)) {
48985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48986 }
48987 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48988 ecode2 = SWIG_AsVal_float(obj1, &val2);
48989 if (!SWIG_IsOK(ecode2)) {
48990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48991 }
48992 arg2 = static_cast< float >(val2);
48993 {
48994 PyThreadState* __tstate = wxPyBeginAllowThreads();
48995 (arg1)->SetRatio(arg2);
48996 wxPyEndAllowThreads(__tstate);
48997 if (PyErr_Occurred()) SWIG_fail;
48998 }
48999 resultobj = SWIG_Py_Void();
49000 return resultobj;
49001 fail:
49002 return NULL;
49003 }
49004
49005
49006 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49007 PyObject *resultobj = 0;
49008 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49009 float result;
49010 void *argp1 = 0 ;
49011 int res1 = 0 ;
49012 PyObject *swig_obj[1] ;
49013
49014 if (!args) SWIG_fail;
49015 swig_obj[0] = args;
49016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49017 if (!SWIG_IsOK(res1)) {
49018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49019 }
49020 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49021 {
49022 PyThreadState* __tstate = wxPyBeginAllowThreads();
49023 result = (float)(arg1)->GetRatio();
49024 wxPyEndAllowThreads(__tstate);
49025 if (PyErr_Occurred()) SWIG_fail;
49026 }
49027 resultobj = SWIG_From_float(static_cast< float >(result));
49028 return resultobj;
49029 fail:
49030 return NULL;
49031 }
49032
49033
49034 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49035 PyObject *resultobj = 0;
49036 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49037 wxRect result;
49038 void *argp1 = 0 ;
49039 int res1 = 0 ;
49040 PyObject *swig_obj[1] ;
49041
49042 if (!args) SWIG_fail;
49043 swig_obj[0] = args;
49044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49045 if (!SWIG_IsOK(res1)) {
49046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49047 }
49048 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 result = (arg1)->GetRect();
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49065 bool result;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 PyObject *swig_obj[1] ;
49069
49070 if (!args) SWIG_fail;
49071 swig_obj[0] = args;
49072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49073 if (!SWIG_IsOK(res1)) {
49074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49075 }
49076 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 result = (bool)(arg1)->IsWindow();
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 {
49084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49085 }
49086 return resultobj;
49087 fail:
49088 return NULL;
49089 }
49090
49091
49092 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49093 PyObject *resultobj = 0;
49094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49095 bool result;
49096 void *argp1 = 0 ;
49097 int res1 = 0 ;
49098 PyObject *swig_obj[1] ;
49099
49100 if (!args) SWIG_fail;
49101 swig_obj[0] = args;
49102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49103 if (!SWIG_IsOK(res1)) {
49104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49105 }
49106 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49107 {
49108 PyThreadState* __tstate = wxPyBeginAllowThreads();
49109 result = (bool)(arg1)->IsSizer();
49110 wxPyEndAllowThreads(__tstate);
49111 if (PyErr_Occurred()) SWIG_fail;
49112 }
49113 {
49114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49115 }
49116 return resultobj;
49117 fail:
49118 return NULL;
49119 }
49120
49121
49122 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49123 PyObject *resultobj = 0;
49124 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49125 bool result;
49126 void *argp1 = 0 ;
49127 int res1 = 0 ;
49128 PyObject *swig_obj[1] ;
49129
49130 if (!args) SWIG_fail;
49131 swig_obj[0] = args;
49132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49133 if (!SWIG_IsOK(res1)) {
49134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49135 }
49136 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49137 {
49138 PyThreadState* __tstate = wxPyBeginAllowThreads();
49139 result = (bool)(arg1)->IsSpacer();
49140 wxPyEndAllowThreads(__tstate);
49141 if (PyErr_Occurred()) SWIG_fail;
49142 }
49143 {
49144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49145 }
49146 return resultobj;
49147 fail:
49148 return NULL;
49149 }
49150
49151
49152 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49153 PyObject *resultobj = 0;
49154 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49155 int arg2 ;
49156 void *argp1 = 0 ;
49157 int res1 = 0 ;
49158 int val2 ;
49159 int ecode2 = 0 ;
49160 PyObject * obj0 = 0 ;
49161 PyObject * obj1 = 0 ;
49162 char * kwnames[] = {
49163 (char *) "self",(char *) "proportion", NULL
49164 };
49165
49166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49168 if (!SWIG_IsOK(res1)) {
49169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49170 }
49171 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49172 ecode2 = SWIG_AsVal_int(obj1, &val2);
49173 if (!SWIG_IsOK(ecode2)) {
49174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49175 }
49176 arg2 = static_cast< int >(val2);
49177 {
49178 PyThreadState* __tstate = wxPyBeginAllowThreads();
49179 (arg1)->SetProportion(arg2);
49180 wxPyEndAllowThreads(__tstate);
49181 if (PyErr_Occurred()) SWIG_fail;
49182 }
49183 resultobj = SWIG_Py_Void();
49184 return resultobj;
49185 fail:
49186 return NULL;
49187 }
49188
49189
49190 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49191 PyObject *resultobj = 0;
49192 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49193 int result;
49194 void *argp1 = 0 ;
49195 int res1 = 0 ;
49196 PyObject *swig_obj[1] ;
49197
49198 if (!args) SWIG_fail;
49199 swig_obj[0] = args;
49200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49201 if (!SWIG_IsOK(res1)) {
49202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49203 }
49204 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49205 {
49206 PyThreadState* __tstate = wxPyBeginAllowThreads();
49207 result = (int)(arg1)->GetProportion();
49208 wxPyEndAllowThreads(__tstate);
49209 if (PyErr_Occurred()) SWIG_fail;
49210 }
49211 resultobj = SWIG_From_int(static_cast< int >(result));
49212 return resultobj;
49213 fail:
49214 return NULL;
49215 }
49216
49217
49218 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49219 PyObject *resultobj = 0;
49220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49221 int arg2 ;
49222 void *argp1 = 0 ;
49223 int res1 = 0 ;
49224 int val2 ;
49225 int ecode2 = 0 ;
49226 PyObject * obj0 = 0 ;
49227 PyObject * obj1 = 0 ;
49228 char * kwnames[] = {
49229 (char *) "self",(char *) "flag", NULL
49230 };
49231
49232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49234 if (!SWIG_IsOK(res1)) {
49235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49236 }
49237 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49238 ecode2 = SWIG_AsVal_int(obj1, &val2);
49239 if (!SWIG_IsOK(ecode2)) {
49240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49241 }
49242 arg2 = static_cast< int >(val2);
49243 {
49244 PyThreadState* __tstate = wxPyBeginAllowThreads();
49245 (arg1)->SetFlag(arg2);
49246 wxPyEndAllowThreads(__tstate);
49247 if (PyErr_Occurred()) SWIG_fail;
49248 }
49249 resultobj = SWIG_Py_Void();
49250 return resultobj;
49251 fail:
49252 return NULL;
49253 }
49254
49255
49256 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49257 PyObject *resultobj = 0;
49258 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49259 int result;
49260 void *argp1 = 0 ;
49261 int res1 = 0 ;
49262 PyObject *swig_obj[1] ;
49263
49264 if (!args) SWIG_fail;
49265 swig_obj[0] = args;
49266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49267 if (!SWIG_IsOK(res1)) {
49268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49269 }
49270 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49271 {
49272 PyThreadState* __tstate = wxPyBeginAllowThreads();
49273 result = (int)(arg1)->GetFlag();
49274 wxPyEndAllowThreads(__tstate);
49275 if (PyErr_Occurred()) SWIG_fail;
49276 }
49277 resultobj = SWIG_From_int(static_cast< int >(result));
49278 return resultobj;
49279 fail:
49280 return NULL;
49281 }
49282
49283
49284 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49285 PyObject *resultobj = 0;
49286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49287 int arg2 ;
49288 void *argp1 = 0 ;
49289 int res1 = 0 ;
49290 int val2 ;
49291 int ecode2 = 0 ;
49292 PyObject * obj0 = 0 ;
49293 PyObject * obj1 = 0 ;
49294 char * kwnames[] = {
49295 (char *) "self",(char *) "border", NULL
49296 };
49297
49298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49300 if (!SWIG_IsOK(res1)) {
49301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49302 }
49303 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49304 ecode2 = SWIG_AsVal_int(obj1, &val2);
49305 if (!SWIG_IsOK(ecode2)) {
49306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49307 }
49308 arg2 = static_cast< int >(val2);
49309 {
49310 PyThreadState* __tstate = wxPyBeginAllowThreads();
49311 (arg1)->SetBorder(arg2);
49312 wxPyEndAllowThreads(__tstate);
49313 if (PyErr_Occurred()) SWIG_fail;
49314 }
49315 resultobj = SWIG_Py_Void();
49316 return resultobj;
49317 fail:
49318 return NULL;
49319 }
49320
49321
49322 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49323 PyObject *resultobj = 0;
49324 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49325 int result;
49326 void *argp1 = 0 ;
49327 int res1 = 0 ;
49328 PyObject *swig_obj[1] ;
49329
49330 if (!args) SWIG_fail;
49331 swig_obj[0] = args;
49332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49333 if (!SWIG_IsOK(res1)) {
49334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49335 }
49336 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49337 {
49338 PyThreadState* __tstate = wxPyBeginAllowThreads();
49339 result = (int)(arg1)->GetBorder();
49340 wxPyEndAllowThreads(__tstate);
49341 if (PyErr_Occurred()) SWIG_fail;
49342 }
49343 resultobj = SWIG_From_int(static_cast< int >(result));
49344 return resultobj;
49345 fail:
49346 return NULL;
49347 }
49348
49349
49350 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49351 PyObject *resultobj = 0;
49352 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49353 wxWindow *result = 0 ;
49354 void *argp1 = 0 ;
49355 int res1 = 0 ;
49356 PyObject *swig_obj[1] ;
49357
49358 if (!args) SWIG_fail;
49359 swig_obj[0] = args;
49360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49361 if (!SWIG_IsOK(res1)) {
49362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49363 }
49364 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49365 {
49366 PyThreadState* __tstate = wxPyBeginAllowThreads();
49367 result = (wxWindow *)(arg1)->GetWindow();
49368 wxPyEndAllowThreads(__tstate);
49369 if (PyErr_Occurred()) SWIG_fail;
49370 }
49371 {
49372 resultobj = wxPyMake_wxObject(result, 0);
49373 }
49374 return resultobj;
49375 fail:
49376 return NULL;
49377 }
49378
49379
49380 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49381 PyObject *resultobj = 0;
49382 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49383 wxWindow *arg2 = (wxWindow *) 0 ;
49384 void *argp1 = 0 ;
49385 int res1 = 0 ;
49386 void *argp2 = 0 ;
49387 int res2 = 0 ;
49388 PyObject * obj0 = 0 ;
49389 PyObject * obj1 = 0 ;
49390 char * kwnames[] = {
49391 (char *) "self",(char *) "window", NULL
49392 };
49393
49394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49396 if (!SWIG_IsOK(res1)) {
49397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49398 }
49399 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49401 if (!SWIG_IsOK(res2)) {
49402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49403 }
49404 arg2 = reinterpret_cast< wxWindow * >(argp2);
49405 {
49406 PyThreadState* __tstate = wxPyBeginAllowThreads();
49407 (arg1)->SetWindow(arg2);
49408 wxPyEndAllowThreads(__tstate);
49409 if (PyErr_Occurred()) SWIG_fail;
49410 }
49411 resultobj = SWIG_Py_Void();
49412 return resultobj;
49413 fail:
49414 return NULL;
49415 }
49416
49417
49418 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49419 PyObject *resultobj = 0;
49420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49421 wxSizer *result = 0 ;
49422 void *argp1 = 0 ;
49423 int res1 = 0 ;
49424 PyObject *swig_obj[1] ;
49425
49426 if (!args) SWIG_fail;
49427 swig_obj[0] = args;
49428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49429 if (!SWIG_IsOK(res1)) {
49430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49431 }
49432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49433 {
49434 PyThreadState* __tstate = wxPyBeginAllowThreads();
49435 result = (wxSizer *)(arg1)->GetSizer();
49436 wxPyEndAllowThreads(__tstate);
49437 if (PyErr_Occurred()) SWIG_fail;
49438 }
49439 {
49440 resultobj = wxPyMake_wxObject(result, (bool)0);
49441 }
49442 return resultobj;
49443 fail:
49444 return NULL;
49445 }
49446
49447
49448 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49449 PyObject *resultobj = 0;
49450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49451 wxSizer *arg2 = (wxSizer *) 0 ;
49452 void *argp1 = 0 ;
49453 int res1 = 0 ;
49454 int res2 = 0 ;
49455 PyObject * obj0 = 0 ;
49456 PyObject * obj1 = 0 ;
49457 char * kwnames[] = {
49458 (char *) "self",(char *) "sizer", NULL
49459 };
49460
49461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49463 if (!SWIG_IsOK(res1)) {
49464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49465 }
49466 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49467 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49468 if (!SWIG_IsOK(res2)) {
49469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49470 }
49471 {
49472 PyThreadState* __tstate = wxPyBeginAllowThreads();
49473 (arg1)->SetSizer(arg2);
49474 wxPyEndAllowThreads(__tstate);
49475 if (PyErr_Occurred()) SWIG_fail;
49476 }
49477 resultobj = SWIG_Py_Void();
49478 return resultobj;
49479 fail:
49480 return NULL;
49481 }
49482
49483
49484 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49485 PyObject *resultobj = 0;
49486 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49487 wxSize result;
49488 void *argp1 = 0 ;
49489 int res1 = 0 ;
49490 PyObject *swig_obj[1] ;
49491
49492 if (!args) SWIG_fail;
49493 swig_obj[0] = args;
49494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49495 if (!SWIG_IsOK(res1)) {
49496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49497 }
49498 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49499 {
49500 PyThreadState* __tstate = wxPyBeginAllowThreads();
49501 result = (arg1)->GetSpacer();
49502 wxPyEndAllowThreads(__tstate);
49503 if (PyErr_Occurred()) SWIG_fail;
49504 }
49505 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49506 return resultobj;
49507 fail:
49508 return NULL;
49509 }
49510
49511
49512 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49513 PyObject *resultobj = 0;
49514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49515 wxSize *arg2 = 0 ;
49516 void *argp1 = 0 ;
49517 int res1 = 0 ;
49518 wxSize temp2 ;
49519 PyObject * obj0 = 0 ;
49520 PyObject * obj1 = 0 ;
49521 char * kwnames[] = {
49522 (char *) "self",(char *) "size", NULL
49523 };
49524
49525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49527 if (!SWIG_IsOK(res1)) {
49528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49529 }
49530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49531 {
49532 arg2 = &temp2;
49533 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49534 }
49535 {
49536 PyThreadState* __tstate = wxPyBeginAllowThreads();
49537 (arg1)->SetSpacer((wxSize const &)*arg2);
49538 wxPyEndAllowThreads(__tstate);
49539 if (PyErr_Occurred()) SWIG_fail;
49540 }
49541 resultobj = SWIG_Py_Void();
49542 return resultobj;
49543 fail:
49544 return NULL;
49545 }
49546
49547
49548 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49549 PyObject *resultobj = 0;
49550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49551 bool arg2 ;
49552 void *argp1 = 0 ;
49553 int res1 = 0 ;
49554 bool val2 ;
49555 int ecode2 = 0 ;
49556 PyObject * obj0 = 0 ;
49557 PyObject * obj1 = 0 ;
49558 char * kwnames[] = {
49559 (char *) "self",(char *) "show", NULL
49560 };
49561
49562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49564 if (!SWIG_IsOK(res1)) {
49565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49566 }
49567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49569 if (!SWIG_IsOK(ecode2)) {
49570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49571 }
49572 arg2 = static_cast< bool >(val2);
49573 {
49574 PyThreadState* __tstate = wxPyBeginAllowThreads();
49575 (arg1)->Show(arg2);
49576 wxPyEndAllowThreads(__tstate);
49577 if (PyErr_Occurred()) SWIG_fail;
49578 }
49579 resultobj = SWIG_Py_Void();
49580 return resultobj;
49581 fail:
49582 return NULL;
49583 }
49584
49585
49586 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49587 PyObject *resultobj = 0;
49588 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49589 bool result;
49590 void *argp1 = 0 ;
49591 int res1 = 0 ;
49592 PyObject *swig_obj[1] ;
49593
49594 if (!args) SWIG_fail;
49595 swig_obj[0] = args;
49596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49597 if (!SWIG_IsOK(res1)) {
49598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49599 }
49600 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49601 {
49602 PyThreadState* __tstate = wxPyBeginAllowThreads();
49603 result = (bool)(arg1)->IsShown();
49604 wxPyEndAllowThreads(__tstate);
49605 if (PyErr_Occurred()) SWIG_fail;
49606 }
49607 {
49608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49609 }
49610 return resultobj;
49611 fail:
49612 return NULL;
49613 }
49614
49615
49616 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49617 PyObject *resultobj = 0;
49618 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49619 wxPoint result;
49620 void *argp1 = 0 ;
49621 int res1 = 0 ;
49622 PyObject *swig_obj[1] ;
49623
49624 if (!args) SWIG_fail;
49625 swig_obj[0] = args;
49626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49627 if (!SWIG_IsOK(res1)) {
49628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49629 }
49630 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49631 {
49632 PyThreadState* __tstate = wxPyBeginAllowThreads();
49633 result = (arg1)->GetPosition();
49634 wxPyEndAllowThreads(__tstate);
49635 if (PyErr_Occurred()) SWIG_fail;
49636 }
49637 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49638 return resultobj;
49639 fail:
49640 return NULL;
49641 }
49642
49643
49644 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49645 PyObject *resultobj = 0;
49646 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49647 PyObject *result = 0 ;
49648 void *argp1 = 0 ;
49649 int res1 = 0 ;
49650 PyObject *swig_obj[1] ;
49651
49652 if (!args) SWIG_fail;
49653 swig_obj[0] = args;
49654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49655 if (!SWIG_IsOK(res1)) {
49656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49657 }
49658 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49659 {
49660 PyThreadState* __tstate = wxPyBeginAllowThreads();
49661 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49662 wxPyEndAllowThreads(__tstate);
49663 if (PyErr_Occurred()) SWIG_fail;
49664 }
49665 resultobj = result;
49666 return resultobj;
49667 fail:
49668 return NULL;
49669 }
49670
49671
49672 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49673 PyObject *resultobj = 0;
49674 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49675 PyObject *arg2 = (PyObject *) 0 ;
49676 void *argp1 = 0 ;
49677 int res1 = 0 ;
49678 PyObject * obj0 = 0 ;
49679 PyObject * obj1 = 0 ;
49680 char * kwnames[] = {
49681 (char *) "self",(char *) "userData", NULL
49682 };
49683
49684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49686 if (!SWIG_IsOK(res1)) {
49687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49688 }
49689 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49690 arg2 = obj1;
49691 {
49692 PyThreadState* __tstate = wxPyBeginAllowThreads();
49693 wxSizerItem_SetUserData(arg1,arg2);
49694 wxPyEndAllowThreads(__tstate);
49695 if (PyErr_Occurred()) SWIG_fail;
49696 }
49697 resultobj = SWIG_Py_Void();
49698 return resultobj;
49699 fail:
49700 return NULL;
49701 }
49702
49703
49704 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49705 PyObject *obj;
49706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49707 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49708 return SWIG_Py_Void();
49709 }
49710
49711 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49712 return SWIG_Python_InitShadowInstance(args);
49713 }
49714
49715 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49716 PyObject *resultobj = 0;
49717 wxSizer *arg1 = (wxSizer *) 0 ;
49718 void *argp1 = 0 ;
49719 int res1 = 0 ;
49720 PyObject *swig_obj[1] ;
49721
49722 if (!args) SWIG_fail;
49723 swig_obj[0] = args;
49724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49725 if (!SWIG_IsOK(res1)) {
49726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49727 }
49728 arg1 = reinterpret_cast< wxSizer * >(argp1);
49729 {
49730 PyThreadState* __tstate = wxPyBeginAllowThreads();
49731 delete arg1;
49732
49733 wxPyEndAllowThreads(__tstate);
49734 if (PyErr_Occurred()) SWIG_fail;
49735 }
49736 resultobj = SWIG_Py_Void();
49737 return resultobj;
49738 fail:
49739 return NULL;
49740 }
49741
49742
49743 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49744 PyObject *resultobj = 0;
49745 wxSizer *arg1 = (wxSizer *) 0 ;
49746 PyObject *arg2 = (PyObject *) 0 ;
49747 void *argp1 = 0 ;
49748 int res1 = 0 ;
49749 PyObject * obj0 = 0 ;
49750 PyObject * obj1 = 0 ;
49751 char * kwnames[] = {
49752 (char *) "self",(char *) "_self", NULL
49753 };
49754
49755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49757 if (!SWIG_IsOK(res1)) {
49758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49759 }
49760 arg1 = reinterpret_cast< wxSizer * >(argp1);
49761 arg2 = obj1;
49762 {
49763 PyThreadState* __tstate = wxPyBeginAllowThreads();
49764 wxSizer__setOORInfo(arg1,arg2);
49765 wxPyEndAllowThreads(__tstate);
49766 if (PyErr_Occurred()) SWIG_fail;
49767 }
49768 resultobj = SWIG_Py_Void();
49769 return resultobj;
49770 fail:
49771 return NULL;
49772 }
49773
49774
49775 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49776 PyObject *resultobj = 0;
49777 wxSizer *arg1 = (wxSizer *) 0 ;
49778 PyObject *arg2 = (PyObject *) 0 ;
49779 int arg3 = (int) 0 ;
49780 int arg4 = (int) 0 ;
49781 int arg5 = (int) 0 ;
49782 PyObject *arg6 = (PyObject *) NULL ;
49783 wxSizerItem *result = 0 ;
49784 void *argp1 = 0 ;
49785 int res1 = 0 ;
49786 int val3 ;
49787 int ecode3 = 0 ;
49788 int val4 ;
49789 int ecode4 = 0 ;
49790 int val5 ;
49791 int ecode5 = 0 ;
49792 PyObject * obj0 = 0 ;
49793 PyObject * obj1 = 0 ;
49794 PyObject * obj2 = 0 ;
49795 PyObject * obj3 = 0 ;
49796 PyObject * obj4 = 0 ;
49797 PyObject * obj5 = 0 ;
49798 char * kwnames[] = {
49799 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49800 };
49801
49802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49804 if (!SWIG_IsOK(res1)) {
49805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49806 }
49807 arg1 = reinterpret_cast< wxSizer * >(argp1);
49808 arg2 = obj1;
49809 if (obj2) {
49810 ecode3 = SWIG_AsVal_int(obj2, &val3);
49811 if (!SWIG_IsOK(ecode3)) {
49812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49813 }
49814 arg3 = static_cast< int >(val3);
49815 }
49816 if (obj3) {
49817 ecode4 = SWIG_AsVal_int(obj3, &val4);
49818 if (!SWIG_IsOK(ecode4)) {
49819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49820 }
49821 arg4 = static_cast< int >(val4);
49822 }
49823 if (obj4) {
49824 ecode5 = SWIG_AsVal_int(obj4, &val5);
49825 if (!SWIG_IsOK(ecode5)) {
49826 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49827 }
49828 arg5 = static_cast< int >(val5);
49829 }
49830 if (obj5) {
49831 arg6 = obj5;
49832 }
49833 {
49834 PyThreadState* __tstate = wxPyBeginAllowThreads();
49835 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49836 wxPyEndAllowThreads(__tstate);
49837 if (PyErr_Occurred()) SWIG_fail;
49838 }
49839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49840 return resultobj;
49841 fail:
49842 return NULL;
49843 }
49844
49845
49846 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49847 PyObject *resultobj = 0;
49848 wxSizer *arg1 = (wxSizer *) 0 ;
49849 int arg2 ;
49850 PyObject *arg3 = (PyObject *) 0 ;
49851 int arg4 = (int) 0 ;
49852 int arg5 = (int) 0 ;
49853 int arg6 = (int) 0 ;
49854 PyObject *arg7 = (PyObject *) NULL ;
49855 wxSizerItem *result = 0 ;
49856 void *argp1 = 0 ;
49857 int res1 = 0 ;
49858 int val2 ;
49859 int ecode2 = 0 ;
49860 int val4 ;
49861 int ecode4 = 0 ;
49862 int val5 ;
49863 int ecode5 = 0 ;
49864 int val6 ;
49865 int ecode6 = 0 ;
49866 PyObject * obj0 = 0 ;
49867 PyObject * obj1 = 0 ;
49868 PyObject * obj2 = 0 ;
49869 PyObject * obj3 = 0 ;
49870 PyObject * obj4 = 0 ;
49871 PyObject * obj5 = 0 ;
49872 PyObject * obj6 = 0 ;
49873 char * kwnames[] = {
49874 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49875 };
49876
49877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49879 if (!SWIG_IsOK(res1)) {
49880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49881 }
49882 arg1 = reinterpret_cast< wxSizer * >(argp1);
49883 ecode2 = SWIG_AsVal_int(obj1, &val2);
49884 if (!SWIG_IsOK(ecode2)) {
49885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49886 }
49887 arg2 = static_cast< int >(val2);
49888 arg3 = obj2;
49889 if (obj3) {
49890 ecode4 = SWIG_AsVal_int(obj3, &val4);
49891 if (!SWIG_IsOK(ecode4)) {
49892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49893 }
49894 arg4 = static_cast< int >(val4);
49895 }
49896 if (obj4) {
49897 ecode5 = SWIG_AsVal_int(obj4, &val5);
49898 if (!SWIG_IsOK(ecode5)) {
49899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49900 }
49901 arg5 = static_cast< int >(val5);
49902 }
49903 if (obj5) {
49904 ecode6 = SWIG_AsVal_int(obj5, &val6);
49905 if (!SWIG_IsOK(ecode6)) {
49906 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49907 }
49908 arg6 = static_cast< int >(val6);
49909 }
49910 if (obj6) {
49911 arg7 = obj6;
49912 }
49913 {
49914 PyThreadState* __tstate = wxPyBeginAllowThreads();
49915 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49916 wxPyEndAllowThreads(__tstate);
49917 if (PyErr_Occurred()) SWIG_fail;
49918 }
49919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49920 return resultobj;
49921 fail:
49922 return NULL;
49923 }
49924
49925
49926 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49927 PyObject *resultobj = 0;
49928 wxSizer *arg1 = (wxSizer *) 0 ;
49929 PyObject *arg2 = (PyObject *) 0 ;
49930 int arg3 = (int) 0 ;
49931 int arg4 = (int) 0 ;
49932 int arg5 = (int) 0 ;
49933 PyObject *arg6 = (PyObject *) NULL ;
49934 wxSizerItem *result = 0 ;
49935 void *argp1 = 0 ;
49936 int res1 = 0 ;
49937 int val3 ;
49938 int ecode3 = 0 ;
49939 int val4 ;
49940 int ecode4 = 0 ;
49941 int val5 ;
49942 int ecode5 = 0 ;
49943 PyObject * obj0 = 0 ;
49944 PyObject * obj1 = 0 ;
49945 PyObject * obj2 = 0 ;
49946 PyObject * obj3 = 0 ;
49947 PyObject * obj4 = 0 ;
49948 PyObject * obj5 = 0 ;
49949 char * kwnames[] = {
49950 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49951 };
49952
49953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49955 if (!SWIG_IsOK(res1)) {
49956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49957 }
49958 arg1 = reinterpret_cast< wxSizer * >(argp1);
49959 arg2 = obj1;
49960 if (obj2) {
49961 ecode3 = SWIG_AsVal_int(obj2, &val3);
49962 if (!SWIG_IsOK(ecode3)) {
49963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49964 }
49965 arg3 = static_cast< int >(val3);
49966 }
49967 if (obj3) {
49968 ecode4 = SWIG_AsVal_int(obj3, &val4);
49969 if (!SWIG_IsOK(ecode4)) {
49970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49971 }
49972 arg4 = static_cast< int >(val4);
49973 }
49974 if (obj4) {
49975 ecode5 = SWIG_AsVal_int(obj4, &val5);
49976 if (!SWIG_IsOK(ecode5)) {
49977 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49978 }
49979 arg5 = static_cast< int >(val5);
49980 }
49981 if (obj5) {
49982 arg6 = obj5;
49983 }
49984 {
49985 PyThreadState* __tstate = wxPyBeginAllowThreads();
49986 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49987 wxPyEndAllowThreads(__tstate);
49988 if (PyErr_Occurred()) SWIG_fail;
49989 }
49990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49991 return resultobj;
49992 fail:
49993 return NULL;
49994 }
49995
49996
49997 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49998 PyObject *resultobj = 0;
49999 wxSizer *arg1 = (wxSizer *) 0 ;
50000 PyObject *arg2 = (PyObject *) 0 ;
50001 bool result;
50002 void *argp1 = 0 ;
50003 int res1 = 0 ;
50004 PyObject * obj0 = 0 ;
50005 PyObject * obj1 = 0 ;
50006 char * kwnames[] = {
50007 (char *) "self",(char *) "item", NULL
50008 };
50009
50010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50012 if (!SWIG_IsOK(res1)) {
50013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50014 }
50015 arg1 = reinterpret_cast< wxSizer * >(argp1);
50016 arg2 = obj1;
50017 {
50018 PyThreadState* __tstate = wxPyBeginAllowThreads();
50019 result = (bool)wxSizer_Remove(arg1,arg2);
50020 wxPyEndAllowThreads(__tstate);
50021 if (PyErr_Occurred()) SWIG_fail;
50022 }
50023 {
50024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50025 }
50026 return resultobj;
50027 fail:
50028 return NULL;
50029 }
50030
50031
50032 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50033 PyObject *resultobj = 0;
50034 wxSizer *arg1 = (wxSizer *) 0 ;
50035 PyObject *arg2 = (PyObject *) 0 ;
50036 bool result;
50037 void *argp1 = 0 ;
50038 int res1 = 0 ;
50039 PyObject * obj0 = 0 ;
50040 PyObject * obj1 = 0 ;
50041 char * kwnames[] = {
50042 (char *) "self",(char *) "item", NULL
50043 };
50044
50045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50047 if (!SWIG_IsOK(res1)) {
50048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50049 }
50050 arg1 = reinterpret_cast< wxSizer * >(argp1);
50051 arg2 = obj1;
50052 {
50053 PyThreadState* __tstate = wxPyBeginAllowThreads();
50054 result = (bool)wxSizer_Detach(arg1,arg2);
50055 wxPyEndAllowThreads(__tstate);
50056 if (PyErr_Occurred()) SWIG_fail;
50057 }
50058 {
50059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50060 }
50061 return resultobj;
50062 fail:
50063 return NULL;
50064 }
50065
50066
50067 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50068 PyObject *resultobj = 0;
50069 wxSizer *arg1 = (wxSizer *) 0 ;
50070 PyObject *arg2 = (PyObject *) 0 ;
50071 wxSizerItem *result = 0 ;
50072 void *argp1 = 0 ;
50073 int res1 = 0 ;
50074 PyObject * obj0 = 0 ;
50075 PyObject * obj1 = 0 ;
50076 char * kwnames[] = {
50077 (char *) "self",(char *) "item", NULL
50078 };
50079
50080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50082 if (!SWIG_IsOK(res1)) {
50083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50084 }
50085 arg1 = reinterpret_cast< wxSizer * >(argp1);
50086 arg2 = obj1;
50087 {
50088 PyThreadState* __tstate = wxPyBeginAllowThreads();
50089 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50090 wxPyEndAllowThreads(__tstate);
50091 if (PyErr_Occurred()) SWIG_fail;
50092 }
50093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50094 return resultobj;
50095 fail:
50096 return NULL;
50097 }
50098
50099
50100 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50101 PyObject *resultobj = 0;
50102 wxSizer *arg1 = (wxSizer *) 0 ;
50103 PyObject *arg2 = (PyObject *) 0 ;
50104 wxSize *arg3 = 0 ;
50105 void *argp1 = 0 ;
50106 int res1 = 0 ;
50107 wxSize temp3 ;
50108 PyObject * obj0 = 0 ;
50109 PyObject * obj1 = 0 ;
50110 PyObject * obj2 = 0 ;
50111 char * kwnames[] = {
50112 (char *) "self",(char *) "item",(char *) "size", NULL
50113 };
50114
50115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50117 if (!SWIG_IsOK(res1)) {
50118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50119 }
50120 arg1 = reinterpret_cast< wxSizer * >(argp1);
50121 arg2 = obj1;
50122 {
50123 arg3 = &temp3;
50124 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50125 }
50126 {
50127 PyThreadState* __tstate = wxPyBeginAllowThreads();
50128 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50129 wxPyEndAllowThreads(__tstate);
50130 if (PyErr_Occurred()) SWIG_fail;
50131 }
50132 resultobj = SWIG_Py_Void();
50133 return resultobj;
50134 fail:
50135 return NULL;
50136 }
50137
50138
50139 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50140 PyObject *resultobj = 0;
50141 wxSizer *arg1 = (wxSizer *) 0 ;
50142 wxWindow *arg2 = (wxWindow *) 0 ;
50143 wxWindow *arg3 = (wxWindow *) 0 ;
50144 bool arg4 = (bool) false ;
50145 bool result;
50146 void *argp1 = 0 ;
50147 int res1 = 0 ;
50148 void *argp2 = 0 ;
50149 int res2 = 0 ;
50150 void *argp3 = 0 ;
50151 int res3 = 0 ;
50152 bool val4 ;
50153 int ecode4 = 0 ;
50154 PyObject * obj0 = 0 ;
50155 PyObject * obj1 = 0 ;
50156 PyObject * obj2 = 0 ;
50157 PyObject * obj3 = 0 ;
50158 char * kwnames[] = {
50159 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50160 };
50161
50162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50164 if (!SWIG_IsOK(res1)) {
50165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50166 }
50167 arg1 = reinterpret_cast< wxSizer * >(argp1);
50168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50169 if (!SWIG_IsOK(res2)) {
50170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50171 }
50172 arg2 = reinterpret_cast< wxWindow * >(argp2);
50173 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50174 if (!SWIG_IsOK(res3)) {
50175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50176 }
50177 arg3 = reinterpret_cast< wxWindow * >(argp3);
50178 if (obj3) {
50179 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50180 if (!SWIG_IsOK(ecode4)) {
50181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50182 }
50183 arg4 = static_cast< bool >(val4);
50184 }
50185 {
50186 PyThreadState* __tstate = wxPyBeginAllowThreads();
50187 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50188 wxPyEndAllowThreads(__tstate);
50189 if (PyErr_Occurred()) SWIG_fail;
50190 }
50191 {
50192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50193 }
50194 return resultobj;
50195 fail:
50196 return NULL;
50197 }
50198
50199
50200 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50201 PyObject *resultobj = 0;
50202 wxSizer *arg1 = (wxSizer *) 0 ;
50203 wxSizer *arg2 = (wxSizer *) 0 ;
50204 wxSizer *arg3 = (wxSizer *) 0 ;
50205 bool arg4 = (bool) false ;
50206 bool result;
50207 void *argp1 = 0 ;
50208 int res1 = 0 ;
50209 void *argp2 = 0 ;
50210 int res2 = 0 ;
50211 void *argp3 = 0 ;
50212 int res3 = 0 ;
50213 bool val4 ;
50214 int ecode4 = 0 ;
50215 PyObject * obj0 = 0 ;
50216 PyObject * obj1 = 0 ;
50217 PyObject * obj2 = 0 ;
50218 PyObject * obj3 = 0 ;
50219 char * kwnames[] = {
50220 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50221 };
50222
50223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50225 if (!SWIG_IsOK(res1)) {
50226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50227 }
50228 arg1 = reinterpret_cast< wxSizer * >(argp1);
50229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50230 if (!SWIG_IsOK(res2)) {
50231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50232 }
50233 arg2 = reinterpret_cast< wxSizer * >(argp2);
50234 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50235 if (!SWIG_IsOK(res3)) {
50236 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50237 }
50238 arg3 = reinterpret_cast< wxSizer * >(argp3);
50239 if (obj3) {
50240 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50241 if (!SWIG_IsOK(ecode4)) {
50242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50243 }
50244 arg4 = static_cast< bool >(val4);
50245 }
50246 {
50247 PyThreadState* __tstate = wxPyBeginAllowThreads();
50248 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50249 wxPyEndAllowThreads(__tstate);
50250 if (PyErr_Occurred()) SWIG_fail;
50251 }
50252 {
50253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50254 }
50255 return resultobj;
50256 fail:
50257 return NULL;
50258 }
50259
50260
50261 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50262 PyObject *resultobj = 0;
50263 wxSizer *arg1 = (wxSizer *) 0 ;
50264 size_t arg2 ;
50265 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50266 bool result;
50267 void *argp1 = 0 ;
50268 int res1 = 0 ;
50269 size_t val2 ;
50270 int ecode2 = 0 ;
50271 void *argp3 = 0 ;
50272 int res3 = 0 ;
50273 PyObject * obj0 = 0 ;
50274 PyObject * obj1 = 0 ;
50275 PyObject * obj2 = 0 ;
50276 char * kwnames[] = {
50277 (char *) "self",(char *) "index",(char *) "newitem", NULL
50278 };
50279
50280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50282 if (!SWIG_IsOK(res1)) {
50283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50284 }
50285 arg1 = reinterpret_cast< wxSizer * >(argp1);
50286 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50287 if (!SWIG_IsOK(ecode2)) {
50288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50289 }
50290 arg2 = static_cast< size_t >(val2);
50291 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50292 if (!SWIG_IsOK(res3)) {
50293 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50294 }
50295 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50296 {
50297 PyThreadState* __tstate = wxPyBeginAllowThreads();
50298 result = (bool)(arg1)->Replace(arg2,arg3);
50299 wxPyEndAllowThreads(__tstate);
50300 if (PyErr_Occurred()) SWIG_fail;
50301 }
50302 {
50303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50304 }
50305 return resultobj;
50306 fail:
50307 return NULL;
50308 }
50309
50310
50311 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50312 PyObject *resultobj = 0;
50313 wxSizer *arg1 = (wxSizer *) 0 ;
50314 wxWindow *arg2 = (wxWindow *) 0 ;
50315 void *argp1 = 0 ;
50316 int res1 = 0 ;
50317 void *argp2 = 0 ;
50318 int res2 = 0 ;
50319 PyObject * obj0 = 0 ;
50320 PyObject * obj1 = 0 ;
50321 char * kwnames[] = {
50322 (char *) "self",(char *) "window", NULL
50323 };
50324
50325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50327 if (!SWIG_IsOK(res1)) {
50328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50329 }
50330 arg1 = reinterpret_cast< wxSizer * >(argp1);
50331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50332 if (!SWIG_IsOK(res2)) {
50333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50334 }
50335 arg2 = reinterpret_cast< wxWindow * >(argp2);
50336 {
50337 PyThreadState* __tstate = wxPyBeginAllowThreads();
50338 (arg1)->SetContainingWindow(arg2);
50339 wxPyEndAllowThreads(__tstate);
50340 if (PyErr_Occurred()) SWIG_fail;
50341 }
50342 resultobj = SWIG_Py_Void();
50343 return resultobj;
50344 fail:
50345 return NULL;
50346 }
50347
50348
50349 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50350 PyObject *resultobj = 0;
50351 wxSizer *arg1 = (wxSizer *) 0 ;
50352 wxWindow *result = 0 ;
50353 void *argp1 = 0 ;
50354 int res1 = 0 ;
50355 PyObject *swig_obj[1] ;
50356
50357 if (!args) SWIG_fail;
50358 swig_obj[0] = args;
50359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50362 }
50363 arg1 = reinterpret_cast< wxSizer * >(argp1);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 {
50371 resultobj = wxPyMake_wxObject(result, 0);
50372 }
50373 return resultobj;
50374 fail:
50375 return NULL;
50376 }
50377
50378
50379 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50380 PyObject *resultobj = 0;
50381 wxSizer *arg1 = (wxSizer *) 0 ;
50382 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50383 wxSizerItem *result = 0 ;
50384 void *argp1 = 0 ;
50385 int res1 = 0 ;
50386 int res2 = 0 ;
50387 PyObject * obj0 = 0 ;
50388 PyObject * obj1 = 0 ;
50389 char * kwnames[] = {
50390 (char *) "self",(char *) "item", NULL
50391 };
50392
50393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50395 if (!SWIG_IsOK(res1)) {
50396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50397 }
50398 arg1 = reinterpret_cast< wxSizer * >(argp1);
50399 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50400 if (!SWIG_IsOK(res2)) {
50401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50402 }
50403 {
50404 PyThreadState* __tstate = wxPyBeginAllowThreads();
50405 result = (wxSizerItem *)(arg1)->Add(arg2);
50406 wxPyEndAllowThreads(__tstate);
50407 if (PyErr_Occurred()) SWIG_fail;
50408 }
50409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50410 return resultobj;
50411 fail:
50412 return NULL;
50413 }
50414
50415
50416 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50417 PyObject *resultobj = 0;
50418 wxSizer *arg1 = (wxSizer *) 0 ;
50419 size_t arg2 ;
50420 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50421 wxSizerItem *result = 0 ;
50422 void *argp1 = 0 ;
50423 int res1 = 0 ;
50424 size_t val2 ;
50425 int ecode2 = 0 ;
50426 int res3 = 0 ;
50427 PyObject * obj0 = 0 ;
50428 PyObject * obj1 = 0 ;
50429 PyObject * obj2 = 0 ;
50430 char * kwnames[] = {
50431 (char *) "self",(char *) "index",(char *) "item", NULL
50432 };
50433
50434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50436 if (!SWIG_IsOK(res1)) {
50437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50438 }
50439 arg1 = reinterpret_cast< wxSizer * >(argp1);
50440 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50441 if (!SWIG_IsOK(ecode2)) {
50442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50443 }
50444 arg2 = static_cast< size_t >(val2);
50445 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50446 if (!SWIG_IsOK(res3)) {
50447 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50448 }
50449 {
50450 PyThreadState* __tstate = wxPyBeginAllowThreads();
50451 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50452 wxPyEndAllowThreads(__tstate);
50453 if (PyErr_Occurred()) SWIG_fail;
50454 }
50455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50456 return resultobj;
50457 fail:
50458 return NULL;
50459 }
50460
50461
50462 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50463 PyObject *resultobj = 0;
50464 wxSizer *arg1 = (wxSizer *) 0 ;
50465 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50466 wxSizerItem *result = 0 ;
50467 void *argp1 = 0 ;
50468 int res1 = 0 ;
50469 int res2 = 0 ;
50470 PyObject * obj0 = 0 ;
50471 PyObject * obj1 = 0 ;
50472 char * kwnames[] = {
50473 (char *) "self",(char *) "item", NULL
50474 };
50475
50476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50478 if (!SWIG_IsOK(res1)) {
50479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50480 }
50481 arg1 = reinterpret_cast< wxSizer * >(argp1);
50482 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50483 if (!SWIG_IsOK(res2)) {
50484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50485 }
50486 {
50487 PyThreadState* __tstate = wxPyBeginAllowThreads();
50488 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50489 wxPyEndAllowThreads(__tstate);
50490 if (PyErr_Occurred()) SWIG_fail;
50491 }
50492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50493 return resultobj;
50494 fail:
50495 return NULL;
50496 }
50497
50498
50499 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50500 PyObject *resultobj = 0;
50501 wxSizer *arg1 = (wxSizer *) 0 ;
50502 int arg2 ;
50503 int arg3 ;
50504 int arg4 ;
50505 int arg5 ;
50506 void *argp1 = 0 ;
50507 int res1 = 0 ;
50508 int val2 ;
50509 int ecode2 = 0 ;
50510 int val3 ;
50511 int ecode3 = 0 ;
50512 int val4 ;
50513 int ecode4 = 0 ;
50514 int val5 ;
50515 int ecode5 = 0 ;
50516 PyObject * obj0 = 0 ;
50517 PyObject * obj1 = 0 ;
50518 PyObject * obj2 = 0 ;
50519 PyObject * obj3 = 0 ;
50520 PyObject * obj4 = 0 ;
50521 char * kwnames[] = {
50522 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50523 };
50524
50525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50527 if (!SWIG_IsOK(res1)) {
50528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50529 }
50530 arg1 = reinterpret_cast< wxSizer * >(argp1);
50531 ecode2 = SWIG_AsVal_int(obj1, &val2);
50532 if (!SWIG_IsOK(ecode2)) {
50533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50534 }
50535 arg2 = static_cast< int >(val2);
50536 ecode3 = SWIG_AsVal_int(obj2, &val3);
50537 if (!SWIG_IsOK(ecode3)) {
50538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50539 }
50540 arg3 = static_cast< int >(val3);
50541 ecode4 = SWIG_AsVal_int(obj3, &val4);
50542 if (!SWIG_IsOK(ecode4)) {
50543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50544 }
50545 arg4 = static_cast< int >(val4);
50546 ecode5 = SWIG_AsVal_int(obj4, &val5);
50547 if (!SWIG_IsOK(ecode5)) {
50548 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50549 }
50550 arg5 = static_cast< int >(val5);
50551 {
50552 PyThreadState* __tstate = wxPyBeginAllowThreads();
50553 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50554 wxPyEndAllowThreads(__tstate);
50555 if (PyErr_Occurred()) SWIG_fail;
50556 }
50557 resultobj = SWIG_Py_Void();
50558 return resultobj;
50559 fail:
50560 return NULL;
50561 }
50562
50563
50564 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50565 PyObject *resultobj = 0;
50566 wxSizer *arg1 = (wxSizer *) 0 ;
50567 wxSize *arg2 = 0 ;
50568 void *argp1 = 0 ;
50569 int res1 = 0 ;
50570 wxSize temp2 ;
50571 PyObject * obj0 = 0 ;
50572 PyObject * obj1 = 0 ;
50573 char * kwnames[] = {
50574 (char *) "self",(char *) "size", NULL
50575 };
50576
50577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50579 if (!SWIG_IsOK(res1)) {
50580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50581 }
50582 arg1 = reinterpret_cast< wxSizer * >(argp1);
50583 {
50584 arg2 = &temp2;
50585 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50586 }
50587 {
50588 PyThreadState* __tstate = wxPyBeginAllowThreads();
50589 (arg1)->SetMinSize((wxSize const &)*arg2);
50590 wxPyEndAllowThreads(__tstate);
50591 if (PyErr_Occurred()) SWIG_fail;
50592 }
50593 resultobj = SWIG_Py_Void();
50594 return resultobj;
50595 fail:
50596 return NULL;
50597 }
50598
50599
50600 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50601 PyObject *resultobj = 0;
50602 wxSizer *arg1 = (wxSizer *) 0 ;
50603 wxSize result;
50604 void *argp1 = 0 ;
50605 int res1 = 0 ;
50606 PyObject *swig_obj[1] ;
50607
50608 if (!args) SWIG_fail;
50609 swig_obj[0] = args;
50610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50611 if (!SWIG_IsOK(res1)) {
50612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50613 }
50614 arg1 = reinterpret_cast< wxSizer * >(argp1);
50615 {
50616 PyThreadState* __tstate = wxPyBeginAllowThreads();
50617 result = (arg1)->GetSize();
50618 wxPyEndAllowThreads(__tstate);
50619 if (PyErr_Occurred()) SWIG_fail;
50620 }
50621 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50622 return resultobj;
50623 fail:
50624 return NULL;
50625 }
50626
50627
50628 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50629 PyObject *resultobj = 0;
50630 wxSizer *arg1 = (wxSizer *) 0 ;
50631 wxPoint result;
50632 void *argp1 = 0 ;
50633 int res1 = 0 ;
50634 PyObject *swig_obj[1] ;
50635
50636 if (!args) SWIG_fail;
50637 swig_obj[0] = args;
50638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50639 if (!SWIG_IsOK(res1)) {
50640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50641 }
50642 arg1 = reinterpret_cast< wxSizer * >(argp1);
50643 {
50644 PyThreadState* __tstate = wxPyBeginAllowThreads();
50645 result = (arg1)->GetPosition();
50646 wxPyEndAllowThreads(__tstate);
50647 if (PyErr_Occurred()) SWIG_fail;
50648 }
50649 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50650 return resultobj;
50651 fail:
50652 return NULL;
50653 }
50654
50655
50656 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50657 PyObject *resultobj = 0;
50658 wxSizer *arg1 = (wxSizer *) 0 ;
50659 wxSize result;
50660 void *argp1 = 0 ;
50661 int res1 = 0 ;
50662 PyObject *swig_obj[1] ;
50663
50664 if (!args) SWIG_fail;
50665 swig_obj[0] = args;
50666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50667 if (!SWIG_IsOK(res1)) {
50668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50669 }
50670 arg1 = reinterpret_cast< wxSizer * >(argp1);
50671 {
50672 PyThreadState* __tstate = wxPyBeginAllowThreads();
50673 result = (arg1)->GetMinSize();
50674 wxPyEndAllowThreads(__tstate);
50675 if (PyErr_Occurred()) SWIG_fail;
50676 }
50677 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50678 return resultobj;
50679 fail:
50680 return NULL;
50681 }
50682
50683
50684 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50685 PyObject *resultobj = 0;
50686 wxSizer *arg1 = (wxSizer *) 0 ;
50687 void *argp1 = 0 ;
50688 int res1 = 0 ;
50689 PyObject *swig_obj[1] ;
50690
50691 if (!args) SWIG_fail;
50692 swig_obj[0] = args;
50693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50694 if (!SWIG_IsOK(res1)) {
50695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50696 }
50697 arg1 = reinterpret_cast< wxSizer * >(argp1);
50698 {
50699 PyThreadState* __tstate = wxPyBeginAllowThreads();
50700 (arg1)->RecalcSizes();
50701 wxPyEndAllowThreads(__tstate);
50702 if (PyErr_Occurred()) SWIG_fail;
50703 }
50704 resultobj = SWIG_Py_Void();
50705 return resultobj;
50706 fail:
50707 return NULL;
50708 }
50709
50710
50711 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50712 PyObject *resultobj = 0;
50713 wxSizer *arg1 = (wxSizer *) 0 ;
50714 wxSize result;
50715 void *argp1 = 0 ;
50716 int res1 = 0 ;
50717 PyObject *swig_obj[1] ;
50718
50719 if (!args) SWIG_fail;
50720 swig_obj[0] = args;
50721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50722 if (!SWIG_IsOK(res1)) {
50723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50724 }
50725 arg1 = reinterpret_cast< wxSizer * >(argp1);
50726 {
50727 PyThreadState* __tstate = wxPyBeginAllowThreads();
50728 result = (arg1)->CalcMin();
50729 wxPyEndAllowThreads(__tstate);
50730 if (PyErr_Occurred()) SWIG_fail;
50731 }
50732 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50733 return resultobj;
50734 fail:
50735 return NULL;
50736 }
50737
50738
50739 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50740 PyObject *resultobj = 0;
50741 wxSizer *arg1 = (wxSizer *) 0 ;
50742 void *argp1 = 0 ;
50743 int res1 = 0 ;
50744 PyObject *swig_obj[1] ;
50745
50746 if (!args) SWIG_fail;
50747 swig_obj[0] = args;
50748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50749 if (!SWIG_IsOK(res1)) {
50750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50751 }
50752 arg1 = reinterpret_cast< wxSizer * >(argp1);
50753 {
50754 PyThreadState* __tstate = wxPyBeginAllowThreads();
50755 (arg1)->Layout();
50756 wxPyEndAllowThreads(__tstate);
50757 if (PyErr_Occurred()) SWIG_fail;
50758 }
50759 resultobj = SWIG_Py_Void();
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50767 PyObject *resultobj = 0;
50768 wxSizer *arg1 = (wxSizer *) 0 ;
50769 wxWindow *arg2 = (wxWindow *) 0 ;
50770 wxSize result;
50771 void *argp1 = 0 ;
50772 int res1 = 0 ;
50773 void *argp2 = 0 ;
50774 int res2 = 0 ;
50775 PyObject * obj0 = 0 ;
50776 PyObject * obj1 = 0 ;
50777 char * kwnames[] = {
50778 (char *) "self",(char *) "window", NULL
50779 };
50780
50781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50783 if (!SWIG_IsOK(res1)) {
50784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50785 }
50786 arg1 = reinterpret_cast< wxSizer * >(argp1);
50787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50788 if (!SWIG_IsOK(res2)) {
50789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50790 }
50791 arg2 = reinterpret_cast< wxWindow * >(argp2);
50792 {
50793 PyThreadState* __tstate = wxPyBeginAllowThreads();
50794 result = (arg1)->Fit(arg2);
50795 wxPyEndAllowThreads(__tstate);
50796 if (PyErr_Occurred()) SWIG_fail;
50797 }
50798 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50799 return resultobj;
50800 fail:
50801 return NULL;
50802 }
50803
50804
50805 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50806 PyObject *resultobj = 0;
50807 wxSizer *arg1 = (wxSizer *) 0 ;
50808 wxWindow *arg2 = (wxWindow *) 0 ;
50809 void *argp1 = 0 ;
50810 int res1 = 0 ;
50811 void *argp2 = 0 ;
50812 int res2 = 0 ;
50813 PyObject * obj0 = 0 ;
50814 PyObject * obj1 = 0 ;
50815 char * kwnames[] = {
50816 (char *) "self",(char *) "window", NULL
50817 };
50818
50819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50821 if (!SWIG_IsOK(res1)) {
50822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50823 }
50824 arg1 = reinterpret_cast< wxSizer * >(argp1);
50825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50826 if (!SWIG_IsOK(res2)) {
50827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50828 }
50829 arg2 = reinterpret_cast< wxWindow * >(argp2);
50830 {
50831 PyThreadState* __tstate = wxPyBeginAllowThreads();
50832 (arg1)->FitInside(arg2);
50833 wxPyEndAllowThreads(__tstate);
50834 if (PyErr_Occurred()) SWIG_fail;
50835 }
50836 resultobj = SWIG_Py_Void();
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50844 PyObject *resultobj = 0;
50845 wxSizer *arg1 = (wxSizer *) 0 ;
50846 wxWindow *arg2 = (wxWindow *) 0 ;
50847 void *argp1 = 0 ;
50848 int res1 = 0 ;
50849 void *argp2 = 0 ;
50850 int res2 = 0 ;
50851 PyObject * obj0 = 0 ;
50852 PyObject * obj1 = 0 ;
50853 char * kwnames[] = {
50854 (char *) "self",(char *) "window", NULL
50855 };
50856
50857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50859 if (!SWIG_IsOK(res1)) {
50860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50861 }
50862 arg1 = reinterpret_cast< wxSizer * >(argp1);
50863 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50864 if (!SWIG_IsOK(res2)) {
50865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50866 }
50867 arg2 = reinterpret_cast< wxWindow * >(argp2);
50868 {
50869 PyThreadState* __tstate = wxPyBeginAllowThreads();
50870 (arg1)->SetSizeHints(arg2);
50871 wxPyEndAllowThreads(__tstate);
50872 if (PyErr_Occurred()) SWIG_fail;
50873 }
50874 resultobj = SWIG_Py_Void();
50875 return resultobj;
50876 fail:
50877 return NULL;
50878 }
50879
50880
50881 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50882 PyObject *resultobj = 0;
50883 wxSizer *arg1 = (wxSizer *) 0 ;
50884 wxWindow *arg2 = (wxWindow *) 0 ;
50885 void *argp1 = 0 ;
50886 int res1 = 0 ;
50887 void *argp2 = 0 ;
50888 int res2 = 0 ;
50889 PyObject * obj0 = 0 ;
50890 PyObject * obj1 = 0 ;
50891 char * kwnames[] = {
50892 (char *) "self",(char *) "window", NULL
50893 };
50894
50895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50897 if (!SWIG_IsOK(res1)) {
50898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50899 }
50900 arg1 = reinterpret_cast< wxSizer * >(argp1);
50901 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50902 if (!SWIG_IsOK(res2)) {
50903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50904 }
50905 arg2 = reinterpret_cast< wxWindow * >(argp2);
50906 {
50907 PyThreadState* __tstate = wxPyBeginAllowThreads();
50908 (arg1)->SetVirtualSizeHints(arg2);
50909 wxPyEndAllowThreads(__tstate);
50910 if (PyErr_Occurred()) SWIG_fail;
50911 }
50912 resultobj = SWIG_Py_Void();
50913 return resultobj;
50914 fail:
50915 return NULL;
50916 }
50917
50918
50919 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50920 PyObject *resultobj = 0;
50921 wxSizer *arg1 = (wxSizer *) 0 ;
50922 bool arg2 = (bool) false ;
50923 void *argp1 = 0 ;
50924 int res1 = 0 ;
50925 bool val2 ;
50926 int ecode2 = 0 ;
50927 PyObject * obj0 = 0 ;
50928 PyObject * obj1 = 0 ;
50929 char * kwnames[] = {
50930 (char *) "self",(char *) "deleteWindows", NULL
50931 };
50932
50933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50935 if (!SWIG_IsOK(res1)) {
50936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50937 }
50938 arg1 = reinterpret_cast< wxSizer * >(argp1);
50939 if (obj1) {
50940 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50941 if (!SWIG_IsOK(ecode2)) {
50942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50943 }
50944 arg2 = static_cast< bool >(val2);
50945 }
50946 {
50947 PyThreadState* __tstate = wxPyBeginAllowThreads();
50948 (arg1)->Clear(arg2);
50949 wxPyEndAllowThreads(__tstate);
50950 if (PyErr_Occurred()) SWIG_fail;
50951 }
50952 resultobj = SWIG_Py_Void();
50953 return resultobj;
50954 fail:
50955 return NULL;
50956 }
50957
50958
50959 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50960 PyObject *resultobj = 0;
50961 wxSizer *arg1 = (wxSizer *) 0 ;
50962 void *argp1 = 0 ;
50963 int res1 = 0 ;
50964 PyObject *swig_obj[1] ;
50965
50966 if (!args) SWIG_fail;
50967 swig_obj[0] = args;
50968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50969 if (!SWIG_IsOK(res1)) {
50970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50971 }
50972 arg1 = reinterpret_cast< wxSizer * >(argp1);
50973 {
50974 PyThreadState* __tstate = wxPyBeginAllowThreads();
50975 (arg1)->DeleteWindows();
50976 wxPyEndAllowThreads(__tstate);
50977 if (PyErr_Occurred()) SWIG_fail;
50978 }
50979 resultobj = SWIG_Py_Void();
50980 return resultobj;
50981 fail:
50982 return NULL;
50983 }
50984
50985
50986 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50987 PyObject *resultobj = 0;
50988 wxSizer *arg1 = (wxSizer *) 0 ;
50989 PyObject *result = 0 ;
50990 void *argp1 = 0 ;
50991 int res1 = 0 ;
50992 PyObject *swig_obj[1] ;
50993
50994 if (!args) SWIG_fail;
50995 swig_obj[0] = args;
50996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50997 if (!SWIG_IsOK(res1)) {
50998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50999 }
51000 arg1 = reinterpret_cast< wxSizer * >(argp1);
51001 {
51002 PyThreadState* __tstate = wxPyBeginAllowThreads();
51003 result = (PyObject *)wxSizer_GetChildren(arg1);
51004 wxPyEndAllowThreads(__tstate);
51005 if (PyErr_Occurred()) SWIG_fail;
51006 }
51007 resultobj = result;
51008 return resultobj;
51009 fail:
51010 return NULL;
51011 }
51012
51013
51014 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51015 PyObject *resultobj = 0;
51016 wxSizer *arg1 = (wxSizer *) 0 ;
51017 PyObject *arg2 = (PyObject *) 0 ;
51018 bool arg3 = (bool) true ;
51019 bool arg4 = (bool) false ;
51020 bool result;
51021 void *argp1 = 0 ;
51022 int res1 = 0 ;
51023 bool val3 ;
51024 int ecode3 = 0 ;
51025 bool val4 ;
51026 int ecode4 = 0 ;
51027 PyObject * obj0 = 0 ;
51028 PyObject * obj1 = 0 ;
51029 PyObject * obj2 = 0 ;
51030 PyObject * obj3 = 0 ;
51031 char * kwnames[] = {
51032 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51033 };
51034
51035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51037 if (!SWIG_IsOK(res1)) {
51038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51039 }
51040 arg1 = reinterpret_cast< wxSizer * >(argp1);
51041 arg2 = obj1;
51042 if (obj2) {
51043 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51044 if (!SWIG_IsOK(ecode3)) {
51045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51046 }
51047 arg3 = static_cast< bool >(val3);
51048 }
51049 if (obj3) {
51050 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51051 if (!SWIG_IsOK(ecode4)) {
51052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51053 }
51054 arg4 = static_cast< bool >(val4);
51055 }
51056 {
51057 PyThreadState* __tstate = wxPyBeginAllowThreads();
51058 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51059 wxPyEndAllowThreads(__tstate);
51060 if (PyErr_Occurred()) SWIG_fail;
51061 }
51062 {
51063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51064 }
51065 return resultobj;
51066 fail:
51067 return NULL;
51068 }
51069
51070
51071 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51072 PyObject *resultobj = 0;
51073 wxSizer *arg1 = (wxSizer *) 0 ;
51074 PyObject *arg2 = (PyObject *) 0 ;
51075 bool result;
51076 void *argp1 = 0 ;
51077 int res1 = 0 ;
51078 PyObject * obj0 = 0 ;
51079 PyObject * obj1 = 0 ;
51080 char * kwnames[] = {
51081 (char *) "self",(char *) "item", NULL
51082 };
51083
51084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51086 if (!SWIG_IsOK(res1)) {
51087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51088 }
51089 arg1 = reinterpret_cast< wxSizer * >(argp1);
51090 arg2 = obj1;
51091 {
51092 PyThreadState* __tstate = wxPyBeginAllowThreads();
51093 result = (bool)wxSizer_IsShown(arg1,arg2);
51094 wxPyEndAllowThreads(__tstate);
51095 if (PyErr_Occurred()) SWIG_fail;
51096 }
51097 {
51098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51099 }
51100 return resultobj;
51101 fail:
51102 return NULL;
51103 }
51104
51105
51106 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51107 PyObject *resultobj = 0;
51108 wxSizer *arg1 = (wxSizer *) 0 ;
51109 bool arg2 ;
51110 void *argp1 = 0 ;
51111 int res1 = 0 ;
51112 bool val2 ;
51113 int ecode2 = 0 ;
51114 PyObject * obj0 = 0 ;
51115 PyObject * obj1 = 0 ;
51116 char * kwnames[] = {
51117 (char *) "self",(char *) "show", NULL
51118 };
51119
51120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51122 if (!SWIG_IsOK(res1)) {
51123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51124 }
51125 arg1 = reinterpret_cast< wxSizer * >(argp1);
51126 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51127 if (!SWIG_IsOK(ecode2)) {
51128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51129 }
51130 arg2 = static_cast< bool >(val2);
51131 {
51132 PyThreadState* __tstate = wxPyBeginAllowThreads();
51133 (arg1)->ShowItems(arg2);
51134 wxPyEndAllowThreads(__tstate);
51135 if (PyErr_Occurred()) SWIG_fail;
51136 }
51137 resultobj = SWIG_Py_Void();
51138 return resultobj;
51139 fail:
51140 return NULL;
51141 }
51142
51143
51144 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51145 PyObject *obj;
51146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51147 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51148 return SWIG_Py_Void();
51149 }
51150
51151 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51152 PyObject *resultobj = 0;
51153 wxPySizer *result = 0 ;
51154
51155 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51156 {
51157 PyThreadState* __tstate = wxPyBeginAllowThreads();
51158 result = (wxPySizer *)new wxPySizer();
51159 wxPyEndAllowThreads(__tstate);
51160 if (PyErr_Occurred()) SWIG_fail;
51161 }
51162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51163 return resultobj;
51164 fail:
51165 return NULL;
51166 }
51167
51168
51169 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51170 PyObject *resultobj = 0;
51171 wxPySizer *arg1 = (wxPySizer *) 0 ;
51172 PyObject *arg2 = (PyObject *) 0 ;
51173 PyObject *arg3 = (PyObject *) 0 ;
51174 void *argp1 = 0 ;
51175 int res1 = 0 ;
51176 PyObject * obj0 = 0 ;
51177 PyObject * obj1 = 0 ;
51178 PyObject * obj2 = 0 ;
51179 char * kwnames[] = {
51180 (char *) "self",(char *) "self",(char *) "_class", NULL
51181 };
51182
51183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51185 if (!SWIG_IsOK(res1)) {
51186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51187 }
51188 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51189 arg2 = obj1;
51190 arg3 = obj2;
51191 {
51192 PyThreadState* __tstate = wxPyBeginAllowThreads();
51193 (arg1)->_setCallbackInfo(arg2,arg3);
51194 wxPyEndAllowThreads(__tstate);
51195 if (PyErr_Occurred()) SWIG_fail;
51196 }
51197 resultobj = SWIG_Py_Void();
51198 return resultobj;
51199 fail:
51200 return NULL;
51201 }
51202
51203
51204 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51205 PyObject *obj;
51206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51207 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51208 return SWIG_Py_Void();
51209 }
51210
51211 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51212 return SWIG_Python_InitShadowInstance(args);
51213 }
51214
51215 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51216 PyObject *resultobj = 0;
51217 int arg1 = (int) wxHORIZONTAL ;
51218 wxBoxSizer *result = 0 ;
51219 int val1 ;
51220 int ecode1 = 0 ;
51221 PyObject * obj0 = 0 ;
51222 char * kwnames[] = {
51223 (char *) "orient", NULL
51224 };
51225
51226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51227 if (obj0) {
51228 ecode1 = SWIG_AsVal_int(obj0, &val1);
51229 if (!SWIG_IsOK(ecode1)) {
51230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51231 }
51232 arg1 = static_cast< int >(val1);
51233 }
51234 {
51235 PyThreadState* __tstate = wxPyBeginAllowThreads();
51236 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51237 wxPyEndAllowThreads(__tstate);
51238 if (PyErr_Occurred()) SWIG_fail;
51239 }
51240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51241 return resultobj;
51242 fail:
51243 return NULL;
51244 }
51245
51246
51247 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51248 PyObject *resultobj = 0;
51249 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51250 int result;
51251 void *argp1 = 0 ;
51252 int res1 = 0 ;
51253 PyObject *swig_obj[1] ;
51254
51255 if (!args) SWIG_fail;
51256 swig_obj[0] = args;
51257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51258 if (!SWIG_IsOK(res1)) {
51259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51260 }
51261 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51262 {
51263 PyThreadState* __tstate = wxPyBeginAllowThreads();
51264 result = (int)(arg1)->GetOrientation();
51265 wxPyEndAllowThreads(__tstate);
51266 if (PyErr_Occurred()) SWIG_fail;
51267 }
51268 resultobj = SWIG_From_int(static_cast< int >(result));
51269 return resultobj;
51270 fail:
51271 return NULL;
51272 }
51273
51274
51275 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51276 PyObject *resultobj = 0;
51277 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51278 int arg2 ;
51279 void *argp1 = 0 ;
51280 int res1 = 0 ;
51281 int val2 ;
51282 int ecode2 = 0 ;
51283 PyObject * obj0 = 0 ;
51284 PyObject * obj1 = 0 ;
51285 char * kwnames[] = {
51286 (char *) "self",(char *) "orient", NULL
51287 };
51288
51289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51291 if (!SWIG_IsOK(res1)) {
51292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51293 }
51294 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51295 ecode2 = SWIG_AsVal_int(obj1, &val2);
51296 if (!SWIG_IsOK(ecode2)) {
51297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51298 }
51299 arg2 = static_cast< int >(val2);
51300 {
51301 PyThreadState* __tstate = wxPyBeginAllowThreads();
51302 (arg1)->SetOrientation(arg2);
51303 wxPyEndAllowThreads(__tstate);
51304 if (PyErr_Occurred()) SWIG_fail;
51305 }
51306 resultobj = SWIG_Py_Void();
51307 return resultobj;
51308 fail:
51309 return NULL;
51310 }
51311
51312
51313 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51314 PyObject *obj;
51315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51316 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51317 return SWIG_Py_Void();
51318 }
51319
51320 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51321 return SWIG_Python_InitShadowInstance(args);
51322 }
51323
51324 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51325 PyObject *resultobj = 0;
51326 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51327 int arg2 = (int) wxHORIZONTAL ;
51328 wxStaticBoxSizer *result = 0 ;
51329 void *argp1 = 0 ;
51330 int res1 = 0 ;
51331 int val2 ;
51332 int ecode2 = 0 ;
51333 PyObject * obj0 = 0 ;
51334 PyObject * obj1 = 0 ;
51335 char * kwnames[] = {
51336 (char *) "box",(char *) "orient", NULL
51337 };
51338
51339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51341 if (!SWIG_IsOK(res1)) {
51342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51343 }
51344 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51345 if (obj1) {
51346 ecode2 = SWIG_AsVal_int(obj1, &val2);
51347 if (!SWIG_IsOK(ecode2)) {
51348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51349 }
51350 arg2 = static_cast< int >(val2);
51351 }
51352 {
51353 PyThreadState* __tstate = wxPyBeginAllowThreads();
51354 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51355 wxPyEndAllowThreads(__tstate);
51356 if (PyErr_Occurred()) SWIG_fail;
51357 }
51358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51359 return resultobj;
51360 fail:
51361 return NULL;
51362 }
51363
51364
51365 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51366 PyObject *resultobj = 0;
51367 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51368 wxStaticBox *result = 0 ;
51369 void *argp1 = 0 ;
51370 int res1 = 0 ;
51371 PyObject *swig_obj[1] ;
51372
51373 if (!args) SWIG_fail;
51374 swig_obj[0] = args;
51375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51376 if (!SWIG_IsOK(res1)) {
51377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51378 }
51379 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51380 {
51381 PyThreadState* __tstate = wxPyBeginAllowThreads();
51382 result = (wxStaticBox *)(arg1)->GetStaticBox();
51383 wxPyEndAllowThreads(__tstate);
51384 if (PyErr_Occurred()) SWIG_fail;
51385 }
51386 {
51387 resultobj = wxPyMake_wxObject(result, (bool)0);
51388 }
51389 return resultobj;
51390 fail:
51391 return NULL;
51392 }
51393
51394
51395 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51396 PyObject *obj;
51397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51398 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51399 return SWIG_Py_Void();
51400 }
51401
51402 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51403 return SWIG_Python_InitShadowInstance(args);
51404 }
51405
51406 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51407 PyObject *resultobj = 0;
51408 int arg1 = (int) 1 ;
51409 int arg2 = (int) 0 ;
51410 int arg3 = (int) 0 ;
51411 int arg4 = (int) 0 ;
51412 wxGridSizer *result = 0 ;
51413 int val1 ;
51414 int ecode1 = 0 ;
51415 int val2 ;
51416 int ecode2 = 0 ;
51417 int val3 ;
51418 int ecode3 = 0 ;
51419 int val4 ;
51420 int ecode4 = 0 ;
51421 PyObject * obj0 = 0 ;
51422 PyObject * obj1 = 0 ;
51423 PyObject * obj2 = 0 ;
51424 PyObject * obj3 = 0 ;
51425 char * kwnames[] = {
51426 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51427 };
51428
51429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51430 if (obj0) {
51431 ecode1 = SWIG_AsVal_int(obj0, &val1);
51432 if (!SWIG_IsOK(ecode1)) {
51433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51434 }
51435 arg1 = static_cast< int >(val1);
51436 }
51437 if (obj1) {
51438 ecode2 = SWIG_AsVal_int(obj1, &val2);
51439 if (!SWIG_IsOK(ecode2)) {
51440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51441 }
51442 arg2 = static_cast< int >(val2);
51443 }
51444 if (obj2) {
51445 ecode3 = SWIG_AsVal_int(obj2, &val3);
51446 if (!SWIG_IsOK(ecode3)) {
51447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51448 }
51449 arg3 = static_cast< int >(val3);
51450 }
51451 if (obj3) {
51452 ecode4 = SWIG_AsVal_int(obj3, &val4);
51453 if (!SWIG_IsOK(ecode4)) {
51454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51455 }
51456 arg4 = static_cast< int >(val4);
51457 }
51458 {
51459 PyThreadState* __tstate = wxPyBeginAllowThreads();
51460 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51461 wxPyEndAllowThreads(__tstate);
51462 if (PyErr_Occurred()) SWIG_fail;
51463 }
51464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51465 return resultobj;
51466 fail:
51467 return NULL;
51468 }
51469
51470
51471 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51472 PyObject *resultobj = 0;
51473 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51474 int arg2 ;
51475 void *argp1 = 0 ;
51476 int res1 = 0 ;
51477 int val2 ;
51478 int ecode2 = 0 ;
51479 PyObject * obj0 = 0 ;
51480 PyObject * obj1 = 0 ;
51481 char * kwnames[] = {
51482 (char *) "self",(char *) "cols", NULL
51483 };
51484
51485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51487 if (!SWIG_IsOK(res1)) {
51488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51489 }
51490 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51491 ecode2 = SWIG_AsVal_int(obj1, &val2);
51492 if (!SWIG_IsOK(ecode2)) {
51493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51494 }
51495 arg2 = static_cast< int >(val2);
51496 {
51497 PyThreadState* __tstate = wxPyBeginAllowThreads();
51498 (arg1)->SetCols(arg2);
51499 wxPyEndAllowThreads(__tstate);
51500 if (PyErr_Occurred()) SWIG_fail;
51501 }
51502 resultobj = SWIG_Py_Void();
51503 return resultobj;
51504 fail:
51505 return NULL;
51506 }
51507
51508
51509 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51510 PyObject *resultobj = 0;
51511 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51512 int arg2 ;
51513 void *argp1 = 0 ;
51514 int res1 = 0 ;
51515 int val2 ;
51516 int ecode2 = 0 ;
51517 PyObject * obj0 = 0 ;
51518 PyObject * obj1 = 0 ;
51519 char * kwnames[] = {
51520 (char *) "self",(char *) "rows", NULL
51521 };
51522
51523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51525 if (!SWIG_IsOK(res1)) {
51526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51527 }
51528 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51529 ecode2 = SWIG_AsVal_int(obj1, &val2);
51530 if (!SWIG_IsOK(ecode2)) {
51531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51532 }
51533 arg2 = static_cast< int >(val2);
51534 {
51535 PyThreadState* __tstate = wxPyBeginAllowThreads();
51536 (arg1)->SetRows(arg2);
51537 wxPyEndAllowThreads(__tstate);
51538 if (PyErr_Occurred()) SWIG_fail;
51539 }
51540 resultobj = SWIG_Py_Void();
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51548 PyObject *resultobj = 0;
51549 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51550 int arg2 ;
51551 void *argp1 = 0 ;
51552 int res1 = 0 ;
51553 int val2 ;
51554 int ecode2 = 0 ;
51555 PyObject * obj0 = 0 ;
51556 PyObject * obj1 = 0 ;
51557 char * kwnames[] = {
51558 (char *) "self",(char *) "gap", NULL
51559 };
51560
51561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51563 if (!SWIG_IsOK(res1)) {
51564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51565 }
51566 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51567 ecode2 = SWIG_AsVal_int(obj1, &val2);
51568 if (!SWIG_IsOK(ecode2)) {
51569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51570 }
51571 arg2 = static_cast< int >(val2);
51572 {
51573 PyThreadState* __tstate = wxPyBeginAllowThreads();
51574 (arg1)->SetVGap(arg2);
51575 wxPyEndAllowThreads(__tstate);
51576 if (PyErr_Occurred()) SWIG_fail;
51577 }
51578 resultobj = SWIG_Py_Void();
51579 return resultobj;
51580 fail:
51581 return NULL;
51582 }
51583
51584
51585 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51586 PyObject *resultobj = 0;
51587 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51588 int arg2 ;
51589 void *argp1 = 0 ;
51590 int res1 = 0 ;
51591 int val2 ;
51592 int ecode2 = 0 ;
51593 PyObject * obj0 = 0 ;
51594 PyObject * obj1 = 0 ;
51595 char * kwnames[] = {
51596 (char *) "self",(char *) "gap", NULL
51597 };
51598
51599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51601 if (!SWIG_IsOK(res1)) {
51602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51603 }
51604 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51605 ecode2 = SWIG_AsVal_int(obj1, &val2);
51606 if (!SWIG_IsOK(ecode2)) {
51607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51608 }
51609 arg2 = static_cast< int >(val2);
51610 {
51611 PyThreadState* __tstate = wxPyBeginAllowThreads();
51612 (arg1)->SetHGap(arg2);
51613 wxPyEndAllowThreads(__tstate);
51614 if (PyErr_Occurred()) SWIG_fail;
51615 }
51616 resultobj = SWIG_Py_Void();
51617 return resultobj;
51618 fail:
51619 return NULL;
51620 }
51621
51622
51623 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51624 PyObject *resultobj = 0;
51625 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51626 int result;
51627 void *argp1 = 0 ;
51628 int res1 = 0 ;
51629 PyObject *swig_obj[1] ;
51630
51631 if (!args) SWIG_fail;
51632 swig_obj[0] = args;
51633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51634 if (!SWIG_IsOK(res1)) {
51635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51636 }
51637 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51638 {
51639 PyThreadState* __tstate = wxPyBeginAllowThreads();
51640 result = (int)(arg1)->GetCols();
51641 wxPyEndAllowThreads(__tstate);
51642 if (PyErr_Occurred()) SWIG_fail;
51643 }
51644 resultobj = SWIG_From_int(static_cast< int >(result));
51645 return resultobj;
51646 fail:
51647 return NULL;
51648 }
51649
51650
51651 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51652 PyObject *resultobj = 0;
51653 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51654 int result;
51655 void *argp1 = 0 ;
51656 int res1 = 0 ;
51657 PyObject *swig_obj[1] ;
51658
51659 if (!args) SWIG_fail;
51660 swig_obj[0] = args;
51661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51662 if (!SWIG_IsOK(res1)) {
51663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51664 }
51665 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51666 {
51667 PyThreadState* __tstate = wxPyBeginAllowThreads();
51668 result = (int)(arg1)->GetRows();
51669 wxPyEndAllowThreads(__tstate);
51670 if (PyErr_Occurred()) SWIG_fail;
51671 }
51672 resultobj = SWIG_From_int(static_cast< int >(result));
51673 return resultobj;
51674 fail:
51675 return NULL;
51676 }
51677
51678
51679 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51680 PyObject *resultobj = 0;
51681 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51682 int result;
51683 void *argp1 = 0 ;
51684 int res1 = 0 ;
51685 PyObject *swig_obj[1] ;
51686
51687 if (!args) SWIG_fail;
51688 swig_obj[0] = args;
51689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51690 if (!SWIG_IsOK(res1)) {
51691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51692 }
51693 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51694 {
51695 PyThreadState* __tstate = wxPyBeginAllowThreads();
51696 result = (int)(arg1)->GetVGap();
51697 wxPyEndAllowThreads(__tstate);
51698 if (PyErr_Occurred()) SWIG_fail;
51699 }
51700 resultobj = SWIG_From_int(static_cast< int >(result));
51701 return resultobj;
51702 fail:
51703 return NULL;
51704 }
51705
51706
51707 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51708 PyObject *resultobj = 0;
51709 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51710 int result;
51711 void *argp1 = 0 ;
51712 int res1 = 0 ;
51713 PyObject *swig_obj[1] ;
51714
51715 if (!args) SWIG_fail;
51716 swig_obj[0] = args;
51717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51718 if (!SWIG_IsOK(res1)) {
51719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51720 }
51721 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51722 {
51723 PyThreadState* __tstate = wxPyBeginAllowThreads();
51724 result = (int)(arg1)->GetHGap();
51725 wxPyEndAllowThreads(__tstate);
51726 if (PyErr_Occurred()) SWIG_fail;
51727 }
51728 resultobj = SWIG_From_int(static_cast< int >(result));
51729 return resultobj;
51730 fail:
51731 return NULL;
51732 }
51733
51734
51735 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51736 PyObject *obj;
51737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51738 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51739 return SWIG_Py_Void();
51740 }
51741
51742 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51743 return SWIG_Python_InitShadowInstance(args);
51744 }
51745
51746 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51747 PyObject *resultobj = 0;
51748 int arg1 = (int) 1 ;
51749 int arg2 = (int) 0 ;
51750 int arg3 = (int) 0 ;
51751 int arg4 = (int) 0 ;
51752 wxFlexGridSizer *result = 0 ;
51753 int val1 ;
51754 int ecode1 = 0 ;
51755 int val2 ;
51756 int ecode2 = 0 ;
51757 int val3 ;
51758 int ecode3 = 0 ;
51759 int val4 ;
51760 int ecode4 = 0 ;
51761 PyObject * obj0 = 0 ;
51762 PyObject * obj1 = 0 ;
51763 PyObject * obj2 = 0 ;
51764 PyObject * obj3 = 0 ;
51765 char * kwnames[] = {
51766 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51767 };
51768
51769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51770 if (obj0) {
51771 ecode1 = SWIG_AsVal_int(obj0, &val1);
51772 if (!SWIG_IsOK(ecode1)) {
51773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51774 }
51775 arg1 = static_cast< int >(val1);
51776 }
51777 if (obj1) {
51778 ecode2 = SWIG_AsVal_int(obj1, &val2);
51779 if (!SWIG_IsOK(ecode2)) {
51780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51781 }
51782 arg2 = static_cast< int >(val2);
51783 }
51784 if (obj2) {
51785 ecode3 = SWIG_AsVal_int(obj2, &val3);
51786 if (!SWIG_IsOK(ecode3)) {
51787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51788 }
51789 arg3 = static_cast< int >(val3);
51790 }
51791 if (obj3) {
51792 ecode4 = SWIG_AsVal_int(obj3, &val4);
51793 if (!SWIG_IsOK(ecode4)) {
51794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51795 }
51796 arg4 = static_cast< int >(val4);
51797 }
51798 {
51799 PyThreadState* __tstate = wxPyBeginAllowThreads();
51800 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51801 wxPyEndAllowThreads(__tstate);
51802 if (PyErr_Occurred()) SWIG_fail;
51803 }
51804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51805 return resultobj;
51806 fail:
51807 return NULL;
51808 }
51809
51810
51811 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51812 PyObject *resultobj = 0;
51813 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51814 size_t arg2 ;
51815 int arg3 = (int) 0 ;
51816 void *argp1 = 0 ;
51817 int res1 = 0 ;
51818 size_t val2 ;
51819 int ecode2 = 0 ;
51820 int val3 ;
51821 int ecode3 = 0 ;
51822 PyObject * obj0 = 0 ;
51823 PyObject * obj1 = 0 ;
51824 PyObject * obj2 = 0 ;
51825 char * kwnames[] = {
51826 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51827 };
51828
51829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51831 if (!SWIG_IsOK(res1)) {
51832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51833 }
51834 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51835 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51836 if (!SWIG_IsOK(ecode2)) {
51837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51838 }
51839 arg2 = static_cast< size_t >(val2);
51840 if (obj2) {
51841 ecode3 = SWIG_AsVal_int(obj2, &val3);
51842 if (!SWIG_IsOK(ecode3)) {
51843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51844 }
51845 arg3 = static_cast< int >(val3);
51846 }
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 (arg1)->AddGrowableRow(arg2,arg3);
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 resultobj = SWIG_Py_Void();
51854 return resultobj;
51855 fail:
51856 return NULL;
51857 }
51858
51859
51860 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51861 PyObject *resultobj = 0;
51862 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51863 size_t arg2 ;
51864 void *argp1 = 0 ;
51865 int res1 = 0 ;
51866 size_t val2 ;
51867 int ecode2 = 0 ;
51868 PyObject * obj0 = 0 ;
51869 PyObject * obj1 = 0 ;
51870 char * kwnames[] = {
51871 (char *) "self",(char *) "idx", NULL
51872 };
51873
51874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51876 if (!SWIG_IsOK(res1)) {
51877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51878 }
51879 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51880 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51881 if (!SWIG_IsOK(ecode2)) {
51882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51883 }
51884 arg2 = static_cast< size_t >(val2);
51885 {
51886 PyThreadState* __tstate = wxPyBeginAllowThreads();
51887 (arg1)->RemoveGrowableRow(arg2);
51888 wxPyEndAllowThreads(__tstate);
51889 if (PyErr_Occurred()) SWIG_fail;
51890 }
51891 resultobj = SWIG_Py_Void();
51892 return resultobj;
51893 fail:
51894 return NULL;
51895 }
51896
51897
51898 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51899 PyObject *resultobj = 0;
51900 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51901 size_t arg2 ;
51902 int arg3 = (int) 0 ;
51903 void *argp1 = 0 ;
51904 int res1 = 0 ;
51905 size_t val2 ;
51906 int ecode2 = 0 ;
51907 int val3 ;
51908 int ecode3 = 0 ;
51909 PyObject * obj0 = 0 ;
51910 PyObject * obj1 = 0 ;
51911 PyObject * obj2 = 0 ;
51912 char * kwnames[] = {
51913 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51914 };
51915
51916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51918 if (!SWIG_IsOK(res1)) {
51919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51920 }
51921 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51922 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51923 if (!SWIG_IsOK(ecode2)) {
51924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51925 }
51926 arg2 = static_cast< size_t >(val2);
51927 if (obj2) {
51928 ecode3 = SWIG_AsVal_int(obj2, &val3);
51929 if (!SWIG_IsOK(ecode3)) {
51930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51931 }
51932 arg3 = static_cast< int >(val3);
51933 }
51934 {
51935 PyThreadState* __tstate = wxPyBeginAllowThreads();
51936 (arg1)->AddGrowableCol(arg2,arg3);
51937 wxPyEndAllowThreads(__tstate);
51938 if (PyErr_Occurred()) SWIG_fail;
51939 }
51940 resultobj = SWIG_Py_Void();
51941 return resultobj;
51942 fail:
51943 return NULL;
51944 }
51945
51946
51947 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51948 PyObject *resultobj = 0;
51949 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51950 size_t arg2 ;
51951 void *argp1 = 0 ;
51952 int res1 = 0 ;
51953 size_t val2 ;
51954 int ecode2 = 0 ;
51955 PyObject * obj0 = 0 ;
51956 PyObject * obj1 = 0 ;
51957 char * kwnames[] = {
51958 (char *) "self",(char *) "idx", NULL
51959 };
51960
51961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51963 if (!SWIG_IsOK(res1)) {
51964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51965 }
51966 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51967 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51968 if (!SWIG_IsOK(ecode2)) {
51969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51970 }
51971 arg2 = static_cast< size_t >(val2);
51972 {
51973 PyThreadState* __tstate = wxPyBeginAllowThreads();
51974 (arg1)->RemoveGrowableCol(arg2);
51975 wxPyEndAllowThreads(__tstate);
51976 if (PyErr_Occurred()) SWIG_fail;
51977 }
51978 resultobj = SWIG_Py_Void();
51979 return resultobj;
51980 fail:
51981 return NULL;
51982 }
51983
51984
51985 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51986 PyObject *resultobj = 0;
51987 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51988 int arg2 ;
51989 void *argp1 = 0 ;
51990 int res1 = 0 ;
51991 int val2 ;
51992 int ecode2 = 0 ;
51993 PyObject * obj0 = 0 ;
51994 PyObject * obj1 = 0 ;
51995 char * kwnames[] = {
51996 (char *) "self",(char *) "direction", NULL
51997 };
51998
51999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52001 if (!SWIG_IsOK(res1)) {
52002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52003 }
52004 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52005 ecode2 = SWIG_AsVal_int(obj1, &val2);
52006 if (!SWIG_IsOK(ecode2)) {
52007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52008 }
52009 arg2 = static_cast< int >(val2);
52010 {
52011 PyThreadState* __tstate = wxPyBeginAllowThreads();
52012 (arg1)->SetFlexibleDirection(arg2);
52013 wxPyEndAllowThreads(__tstate);
52014 if (PyErr_Occurred()) SWIG_fail;
52015 }
52016 resultobj = SWIG_Py_Void();
52017 return resultobj;
52018 fail:
52019 return NULL;
52020 }
52021
52022
52023 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52024 PyObject *resultobj = 0;
52025 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52026 int result;
52027 void *argp1 = 0 ;
52028 int res1 = 0 ;
52029 PyObject *swig_obj[1] ;
52030
52031 if (!args) SWIG_fail;
52032 swig_obj[0] = args;
52033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52034 if (!SWIG_IsOK(res1)) {
52035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52036 }
52037 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52038 {
52039 PyThreadState* __tstate = wxPyBeginAllowThreads();
52040 result = (int)(arg1)->GetFlexibleDirection();
52041 wxPyEndAllowThreads(__tstate);
52042 if (PyErr_Occurred()) SWIG_fail;
52043 }
52044 resultobj = SWIG_From_int(static_cast< int >(result));
52045 return resultobj;
52046 fail:
52047 return NULL;
52048 }
52049
52050
52051 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52052 PyObject *resultobj = 0;
52053 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52054 wxFlexSizerGrowMode arg2 ;
52055 void *argp1 = 0 ;
52056 int res1 = 0 ;
52057 int val2 ;
52058 int ecode2 = 0 ;
52059 PyObject * obj0 = 0 ;
52060 PyObject * obj1 = 0 ;
52061 char * kwnames[] = {
52062 (char *) "self",(char *) "mode", NULL
52063 };
52064
52065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52067 if (!SWIG_IsOK(res1)) {
52068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52069 }
52070 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52071 ecode2 = SWIG_AsVal_int(obj1, &val2);
52072 if (!SWIG_IsOK(ecode2)) {
52073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52074 }
52075 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52076 {
52077 PyThreadState* __tstate = wxPyBeginAllowThreads();
52078 (arg1)->SetNonFlexibleGrowMode(arg2);
52079 wxPyEndAllowThreads(__tstate);
52080 if (PyErr_Occurred()) SWIG_fail;
52081 }
52082 resultobj = SWIG_Py_Void();
52083 return resultobj;
52084 fail:
52085 return NULL;
52086 }
52087
52088
52089 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52090 PyObject *resultobj = 0;
52091 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52092 wxFlexSizerGrowMode result;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 PyObject *swig_obj[1] ;
52096
52097 if (!args) SWIG_fail;
52098 swig_obj[0] = args;
52099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52100 if (!SWIG_IsOK(res1)) {
52101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52102 }
52103 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52104 {
52105 PyThreadState* __tstate = wxPyBeginAllowThreads();
52106 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52107 wxPyEndAllowThreads(__tstate);
52108 if (PyErr_Occurred()) SWIG_fail;
52109 }
52110 resultobj = SWIG_From_int(static_cast< int >(result));
52111 return resultobj;
52112 fail:
52113 return NULL;
52114 }
52115
52116
52117 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52118 PyObject *resultobj = 0;
52119 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52120 wxArrayInt *result = 0 ;
52121 void *argp1 = 0 ;
52122 int res1 = 0 ;
52123 PyObject *swig_obj[1] ;
52124
52125 if (!args) SWIG_fail;
52126 swig_obj[0] = args;
52127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52128 if (!SWIG_IsOK(res1)) {
52129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52130 }
52131 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52132 {
52133 PyThreadState* __tstate = wxPyBeginAllowThreads();
52134 {
52135 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52136 result = (wxArrayInt *) &_result_ref;
52137 }
52138 wxPyEndAllowThreads(__tstate);
52139 if (PyErr_Occurred()) SWIG_fail;
52140 }
52141 {
52142 resultobj = wxArrayInt2PyList_helper(*result);
52143 }
52144 return resultobj;
52145 fail:
52146 return NULL;
52147 }
52148
52149
52150 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52151 PyObject *resultobj = 0;
52152 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52153 wxArrayInt *result = 0 ;
52154 void *argp1 = 0 ;
52155 int res1 = 0 ;
52156 PyObject *swig_obj[1] ;
52157
52158 if (!args) SWIG_fail;
52159 swig_obj[0] = args;
52160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52161 if (!SWIG_IsOK(res1)) {
52162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52163 }
52164 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52165 {
52166 PyThreadState* __tstate = wxPyBeginAllowThreads();
52167 {
52168 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52169 result = (wxArrayInt *) &_result_ref;
52170 }
52171 wxPyEndAllowThreads(__tstate);
52172 if (PyErr_Occurred()) SWIG_fail;
52173 }
52174 {
52175 resultobj = wxArrayInt2PyList_helper(*result);
52176 }
52177 return resultobj;
52178 fail:
52179 return NULL;
52180 }
52181
52182
52183 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52184 PyObject *obj;
52185 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52186 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52187 return SWIG_Py_Void();
52188 }
52189
52190 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52191 return SWIG_Python_InitShadowInstance(args);
52192 }
52193
52194 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52195 PyObject *resultobj = 0;
52196 wxStdDialogButtonSizer *result = 0 ;
52197
52198 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52199 {
52200 PyThreadState* __tstate = wxPyBeginAllowThreads();
52201 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52202 wxPyEndAllowThreads(__tstate);
52203 if (PyErr_Occurred()) SWIG_fail;
52204 }
52205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52206 return resultobj;
52207 fail:
52208 return NULL;
52209 }
52210
52211
52212 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52213 PyObject *resultobj = 0;
52214 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52215 wxButton *arg2 = (wxButton *) 0 ;
52216 void *argp1 = 0 ;
52217 int res1 = 0 ;
52218 void *argp2 = 0 ;
52219 int res2 = 0 ;
52220 PyObject * obj0 = 0 ;
52221 PyObject * obj1 = 0 ;
52222 char * kwnames[] = {
52223 (char *) "self",(char *) "button", NULL
52224 };
52225
52226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52228 if (!SWIG_IsOK(res1)) {
52229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52230 }
52231 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52233 if (!SWIG_IsOK(res2)) {
52234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52235 }
52236 arg2 = reinterpret_cast< wxButton * >(argp2);
52237 {
52238 PyThreadState* __tstate = wxPyBeginAllowThreads();
52239 (arg1)->AddButton(arg2);
52240 wxPyEndAllowThreads(__tstate);
52241 if (PyErr_Occurred()) SWIG_fail;
52242 }
52243 resultobj = SWIG_Py_Void();
52244 return resultobj;
52245 fail:
52246 return NULL;
52247 }
52248
52249
52250 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52251 PyObject *resultobj = 0;
52252 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52253 void *argp1 = 0 ;
52254 int res1 = 0 ;
52255 PyObject *swig_obj[1] ;
52256
52257 if (!args) SWIG_fail;
52258 swig_obj[0] = args;
52259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52260 if (!SWIG_IsOK(res1)) {
52261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52262 }
52263 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52264 {
52265 PyThreadState* __tstate = wxPyBeginAllowThreads();
52266 (arg1)->Realize();
52267 wxPyEndAllowThreads(__tstate);
52268 if (PyErr_Occurred()) SWIG_fail;
52269 }
52270 resultobj = SWIG_Py_Void();
52271 return resultobj;
52272 fail:
52273 return NULL;
52274 }
52275
52276
52277 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52278 PyObject *resultobj = 0;
52279 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52280 wxButton *arg2 = (wxButton *) 0 ;
52281 void *argp1 = 0 ;
52282 int res1 = 0 ;
52283 void *argp2 = 0 ;
52284 int res2 = 0 ;
52285 PyObject * obj0 = 0 ;
52286 PyObject * obj1 = 0 ;
52287 char * kwnames[] = {
52288 (char *) "self",(char *) "button", NULL
52289 };
52290
52291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52293 if (!SWIG_IsOK(res1)) {
52294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52295 }
52296 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52298 if (!SWIG_IsOK(res2)) {
52299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52300 }
52301 arg2 = reinterpret_cast< wxButton * >(argp2);
52302 {
52303 PyThreadState* __tstate = wxPyBeginAllowThreads();
52304 (arg1)->SetAffirmativeButton(arg2);
52305 wxPyEndAllowThreads(__tstate);
52306 if (PyErr_Occurred()) SWIG_fail;
52307 }
52308 resultobj = SWIG_Py_Void();
52309 return resultobj;
52310 fail:
52311 return NULL;
52312 }
52313
52314
52315 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52316 PyObject *resultobj = 0;
52317 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52318 wxButton *arg2 = (wxButton *) 0 ;
52319 void *argp1 = 0 ;
52320 int res1 = 0 ;
52321 void *argp2 = 0 ;
52322 int res2 = 0 ;
52323 PyObject * obj0 = 0 ;
52324 PyObject * obj1 = 0 ;
52325 char * kwnames[] = {
52326 (char *) "self",(char *) "button", NULL
52327 };
52328
52329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52331 if (!SWIG_IsOK(res1)) {
52332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52333 }
52334 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52336 if (!SWIG_IsOK(res2)) {
52337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52338 }
52339 arg2 = reinterpret_cast< wxButton * >(argp2);
52340 {
52341 PyThreadState* __tstate = wxPyBeginAllowThreads();
52342 (arg1)->SetNegativeButton(arg2);
52343 wxPyEndAllowThreads(__tstate);
52344 if (PyErr_Occurred()) SWIG_fail;
52345 }
52346 resultobj = SWIG_Py_Void();
52347 return resultobj;
52348 fail:
52349 return NULL;
52350 }
52351
52352
52353 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52354 PyObject *resultobj = 0;
52355 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52356 wxButton *arg2 = (wxButton *) 0 ;
52357 void *argp1 = 0 ;
52358 int res1 = 0 ;
52359 void *argp2 = 0 ;
52360 int res2 = 0 ;
52361 PyObject * obj0 = 0 ;
52362 PyObject * obj1 = 0 ;
52363 char * kwnames[] = {
52364 (char *) "self",(char *) "button", NULL
52365 };
52366
52367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52369 if (!SWIG_IsOK(res1)) {
52370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52371 }
52372 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52374 if (!SWIG_IsOK(res2)) {
52375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52376 }
52377 arg2 = reinterpret_cast< wxButton * >(argp2);
52378 {
52379 PyThreadState* __tstate = wxPyBeginAllowThreads();
52380 (arg1)->SetCancelButton(arg2);
52381 wxPyEndAllowThreads(__tstate);
52382 if (PyErr_Occurred()) SWIG_fail;
52383 }
52384 resultobj = SWIG_Py_Void();
52385 return resultobj;
52386 fail:
52387 return NULL;
52388 }
52389
52390
52391 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52392 PyObject *resultobj = 0;
52393 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52394 wxButton *result = 0 ;
52395 void *argp1 = 0 ;
52396 int res1 = 0 ;
52397 PyObject *swig_obj[1] ;
52398
52399 if (!args) SWIG_fail;
52400 swig_obj[0] = args;
52401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52402 if (!SWIG_IsOK(res1)) {
52403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52404 }
52405 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52406 {
52407 PyThreadState* __tstate = wxPyBeginAllowThreads();
52408 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52409 wxPyEndAllowThreads(__tstate);
52410 if (PyErr_Occurred()) SWIG_fail;
52411 }
52412 {
52413 resultobj = wxPyMake_wxObject(result, (bool)0);
52414 }
52415 return resultobj;
52416 fail:
52417 return NULL;
52418 }
52419
52420
52421 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52422 PyObject *resultobj = 0;
52423 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52424 wxButton *result = 0 ;
52425 void *argp1 = 0 ;
52426 int res1 = 0 ;
52427 PyObject *swig_obj[1] ;
52428
52429 if (!args) SWIG_fail;
52430 swig_obj[0] = args;
52431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52432 if (!SWIG_IsOK(res1)) {
52433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52434 }
52435 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52436 {
52437 PyThreadState* __tstate = wxPyBeginAllowThreads();
52438 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52439 wxPyEndAllowThreads(__tstate);
52440 if (PyErr_Occurred()) SWIG_fail;
52441 }
52442 {
52443 resultobj = wxPyMake_wxObject(result, (bool)0);
52444 }
52445 return resultobj;
52446 fail:
52447 return NULL;
52448 }
52449
52450
52451 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52452 PyObject *resultobj = 0;
52453 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52454 wxButton *result = 0 ;
52455 void *argp1 = 0 ;
52456 int res1 = 0 ;
52457 PyObject *swig_obj[1] ;
52458
52459 if (!args) SWIG_fail;
52460 swig_obj[0] = args;
52461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52462 if (!SWIG_IsOK(res1)) {
52463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52464 }
52465 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52466 {
52467 PyThreadState* __tstate = wxPyBeginAllowThreads();
52468 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52469 wxPyEndAllowThreads(__tstate);
52470 if (PyErr_Occurred()) SWIG_fail;
52471 }
52472 {
52473 resultobj = wxPyMake_wxObject(result, (bool)0);
52474 }
52475 return resultobj;
52476 fail:
52477 return NULL;
52478 }
52479
52480
52481 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52482 PyObject *resultobj = 0;
52483 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52484 wxButton *result = 0 ;
52485 void *argp1 = 0 ;
52486 int res1 = 0 ;
52487 PyObject *swig_obj[1] ;
52488
52489 if (!args) SWIG_fail;
52490 swig_obj[0] = args;
52491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52492 if (!SWIG_IsOK(res1)) {
52493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52494 }
52495 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52496 {
52497 PyThreadState* __tstate = wxPyBeginAllowThreads();
52498 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52499 wxPyEndAllowThreads(__tstate);
52500 if (PyErr_Occurred()) SWIG_fail;
52501 }
52502 {
52503 resultobj = wxPyMake_wxObject(result, (bool)0);
52504 }
52505 return resultobj;
52506 fail:
52507 return NULL;
52508 }
52509
52510
52511 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52512 PyObject *resultobj = 0;
52513 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52514 wxButton *result = 0 ;
52515 void *argp1 = 0 ;
52516 int res1 = 0 ;
52517 PyObject *swig_obj[1] ;
52518
52519 if (!args) SWIG_fail;
52520 swig_obj[0] = args;
52521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52522 if (!SWIG_IsOK(res1)) {
52523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52524 }
52525 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52526 {
52527 PyThreadState* __tstate = wxPyBeginAllowThreads();
52528 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52529 wxPyEndAllowThreads(__tstate);
52530 if (PyErr_Occurred()) SWIG_fail;
52531 }
52532 {
52533 resultobj = wxPyMake_wxObject(result, (bool)0);
52534 }
52535 return resultobj;
52536 fail:
52537 return NULL;
52538 }
52539
52540
52541 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52542 PyObject *obj;
52543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52544 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52545 return SWIG_Py_Void();
52546 }
52547
52548 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52549 return SWIG_Python_InitShadowInstance(args);
52550 }
52551
52552 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52553 PyObject *resultobj = 0;
52554 int arg1 = (int) 0 ;
52555 int arg2 = (int) 0 ;
52556 wxGBPosition *result = 0 ;
52557 int val1 ;
52558 int ecode1 = 0 ;
52559 int val2 ;
52560 int ecode2 = 0 ;
52561 PyObject * obj0 = 0 ;
52562 PyObject * obj1 = 0 ;
52563 char * kwnames[] = {
52564 (char *) "row",(char *) "col", NULL
52565 };
52566
52567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52568 if (obj0) {
52569 ecode1 = SWIG_AsVal_int(obj0, &val1);
52570 if (!SWIG_IsOK(ecode1)) {
52571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52572 }
52573 arg1 = static_cast< int >(val1);
52574 }
52575 if (obj1) {
52576 ecode2 = SWIG_AsVal_int(obj1, &val2);
52577 if (!SWIG_IsOK(ecode2)) {
52578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52579 }
52580 arg2 = static_cast< int >(val2);
52581 }
52582 {
52583 PyThreadState* __tstate = wxPyBeginAllowThreads();
52584 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52585 wxPyEndAllowThreads(__tstate);
52586 if (PyErr_Occurred()) SWIG_fail;
52587 }
52588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52589 return resultobj;
52590 fail:
52591 return NULL;
52592 }
52593
52594
52595 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52596 PyObject *resultobj = 0;
52597 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52598 void *argp1 = 0 ;
52599 int res1 = 0 ;
52600 PyObject *swig_obj[1] ;
52601
52602 if (!args) SWIG_fail;
52603 swig_obj[0] = args;
52604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52605 if (!SWIG_IsOK(res1)) {
52606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52607 }
52608 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52609 {
52610 PyThreadState* __tstate = wxPyBeginAllowThreads();
52611 delete arg1;
52612
52613 wxPyEndAllowThreads(__tstate);
52614 if (PyErr_Occurred()) SWIG_fail;
52615 }
52616 resultobj = SWIG_Py_Void();
52617 return resultobj;
52618 fail:
52619 return NULL;
52620 }
52621
52622
52623 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52624 PyObject *resultobj = 0;
52625 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52626 int result;
52627 void *argp1 = 0 ;
52628 int res1 = 0 ;
52629 PyObject *swig_obj[1] ;
52630
52631 if (!args) SWIG_fail;
52632 swig_obj[0] = args;
52633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52634 if (!SWIG_IsOK(res1)) {
52635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52636 }
52637 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52638 {
52639 PyThreadState* __tstate = wxPyBeginAllowThreads();
52640 result = (int)((wxGBPosition const *)arg1)->GetRow();
52641 wxPyEndAllowThreads(__tstate);
52642 if (PyErr_Occurred()) SWIG_fail;
52643 }
52644 resultobj = SWIG_From_int(static_cast< int >(result));
52645 return resultobj;
52646 fail:
52647 return NULL;
52648 }
52649
52650
52651 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52652 PyObject *resultobj = 0;
52653 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52654 int result;
52655 void *argp1 = 0 ;
52656 int res1 = 0 ;
52657 PyObject *swig_obj[1] ;
52658
52659 if (!args) SWIG_fail;
52660 swig_obj[0] = args;
52661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52662 if (!SWIG_IsOK(res1)) {
52663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52664 }
52665 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52666 {
52667 PyThreadState* __tstate = wxPyBeginAllowThreads();
52668 result = (int)((wxGBPosition const *)arg1)->GetCol();
52669 wxPyEndAllowThreads(__tstate);
52670 if (PyErr_Occurred()) SWIG_fail;
52671 }
52672 resultobj = SWIG_From_int(static_cast< int >(result));
52673 return resultobj;
52674 fail:
52675 return NULL;
52676 }
52677
52678
52679 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52680 PyObject *resultobj = 0;
52681 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52682 int arg2 ;
52683 void *argp1 = 0 ;
52684 int res1 = 0 ;
52685 int val2 ;
52686 int ecode2 = 0 ;
52687 PyObject * obj0 = 0 ;
52688 PyObject * obj1 = 0 ;
52689 char * kwnames[] = {
52690 (char *) "self",(char *) "row", NULL
52691 };
52692
52693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52695 if (!SWIG_IsOK(res1)) {
52696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52697 }
52698 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52699 ecode2 = SWIG_AsVal_int(obj1, &val2);
52700 if (!SWIG_IsOK(ecode2)) {
52701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52702 }
52703 arg2 = static_cast< int >(val2);
52704 {
52705 PyThreadState* __tstate = wxPyBeginAllowThreads();
52706 (arg1)->SetRow(arg2);
52707 wxPyEndAllowThreads(__tstate);
52708 if (PyErr_Occurred()) SWIG_fail;
52709 }
52710 resultobj = SWIG_Py_Void();
52711 return resultobj;
52712 fail:
52713 return NULL;
52714 }
52715
52716
52717 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52718 PyObject *resultobj = 0;
52719 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52720 int arg2 ;
52721 void *argp1 = 0 ;
52722 int res1 = 0 ;
52723 int val2 ;
52724 int ecode2 = 0 ;
52725 PyObject * obj0 = 0 ;
52726 PyObject * obj1 = 0 ;
52727 char * kwnames[] = {
52728 (char *) "self",(char *) "col", NULL
52729 };
52730
52731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52733 if (!SWIG_IsOK(res1)) {
52734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52735 }
52736 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52737 ecode2 = SWIG_AsVal_int(obj1, &val2);
52738 if (!SWIG_IsOK(ecode2)) {
52739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52740 }
52741 arg2 = static_cast< int >(val2);
52742 {
52743 PyThreadState* __tstate = wxPyBeginAllowThreads();
52744 (arg1)->SetCol(arg2);
52745 wxPyEndAllowThreads(__tstate);
52746 if (PyErr_Occurred()) SWIG_fail;
52747 }
52748 resultobj = SWIG_Py_Void();
52749 return resultobj;
52750 fail:
52751 return NULL;
52752 }
52753
52754
52755 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52756 PyObject *resultobj = 0;
52757 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52758 PyObject *arg2 = (PyObject *) 0 ;
52759 bool result;
52760 void *argp1 = 0 ;
52761 int res1 = 0 ;
52762 PyObject * obj0 = 0 ;
52763 PyObject * obj1 = 0 ;
52764 char * kwnames[] = {
52765 (char *) "self",(char *) "other", NULL
52766 };
52767
52768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52770 if (!SWIG_IsOK(res1)) {
52771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52772 }
52773 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52774 arg2 = obj1;
52775 {
52776 result = (bool)wxGBPosition___eq__(arg1,arg2);
52777 if (PyErr_Occurred()) SWIG_fail;
52778 }
52779 {
52780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52781 }
52782 return resultobj;
52783 fail:
52784 return NULL;
52785 }
52786
52787
52788 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52789 PyObject *resultobj = 0;
52790 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52791 PyObject *arg2 = (PyObject *) 0 ;
52792 bool result;
52793 void *argp1 = 0 ;
52794 int res1 = 0 ;
52795 PyObject * obj0 = 0 ;
52796 PyObject * obj1 = 0 ;
52797 char * kwnames[] = {
52798 (char *) "self",(char *) "other", NULL
52799 };
52800
52801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52803 if (!SWIG_IsOK(res1)) {
52804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52805 }
52806 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52807 arg2 = obj1;
52808 {
52809 result = (bool)wxGBPosition___ne__(arg1,arg2);
52810 if (PyErr_Occurred()) SWIG_fail;
52811 }
52812 {
52813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52814 }
52815 return resultobj;
52816 fail:
52817 return NULL;
52818 }
52819
52820
52821 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52822 PyObject *resultobj = 0;
52823 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52824 int arg2 = (int) 0 ;
52825 int arg3 = (int) 0 ;
52826 void *argp1 = 0 ;
52827 int res1 = 0 ;
52828 int val2 ;
52829 int ecode2 = 0 ;
52830 int val3 ;
52831 int ecode3 = 0 ;
52832 PyObject * obj0 = 0 ;
52833 PyObject * obj1 = 0 ;
52834 PyObject * obj2 = 0 ;
52835 char * kwnames[] = {
52836 (char *) "self",(char *) "row",(char *) "col", NULL
52837 };
52838
52839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52841 if (!SWIG_IsOK(res1)) {
52842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52843 }
52844 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52845 if (obj1) {
52846 ecode2 = SWIG_AsVal_int(obj1, &val2);
52847 if (!SWIG_IsOK(ecode2)) {
52848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52849 }
52850 arg2 = static_cast< int >(val2);
52851 }
52852 if (obj2) {
52853 ecode3 = SWIG_AsVal_int(obj2, &val3);
52854 if (!SWIG_IsOK(ecode3)) {
52855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52856 }
52857 arg3 = static_cast< int >(val3);
52858 }
52859 {
52860 PyThreadState* __tstate = wxPyBeginAllowThreads();
52861 wxGBPosition_Set(arg1,arg2,arg3);
52862 wxPyEndAllowThreads(__tstate);
52863 if (PyErr_Occurred()) SWIG_fail;
52864 }
52865 resultobj = SWIG_Py_Void();
52866 return resultobj;
52867 fail:
52868 return NULL;
52869 }
52870
52871
52872 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52873 PyObject *resultobj = 0;
52874 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52875 PyObject *result = 0 ;
52876 void *argp1 = 0 ;
52877 int res1 = 0 ;
52878 PyObject *swig_obj[1] ;
52879
52880 if (!args) SWIG_fail;
52881 swig_obj[0] = args;
52882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52883 if (!SWIG_IsOK(res1)) {
52884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52885 }
52886 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52887 {
52888 PyThreadState* __tstate = wxPyBeginAllowThreads();
52889 result = (PyObject *)wxGBPosition_Get(arg1);
52890 wxPyEndAllowThreads(__tstate);
52891 if (PyErr_Occurred()) SWIG_fail;
52892 }
52893 resultobj = result;
52894 return resultobj;
52895 fail:
52896 return NULL;
52897 }
52898
52899
52900 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52901 PyObject *obj;
52902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52903 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52904 return SWIG_Py_Void();
52905 }
52906
52907 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52908 return SWIG_Python_InitShadowInstance(args);
52909 }
52910
52911 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52912 PyObject *resultobj = 0;
52913 int arg1 = (int) 1 ;
52914 int arg2 = (int) 1 ;
52915 wxGBSpan *result = 0 ;
52916 int val1 ;
52917 int ecode1 = 0 ;
52918 int val2 ;
52919 int ecode2 = 0 ;
52920 PyObject * obj0 = 0 ;
52921 PyObject * obj1 = 0 ;
52922 char * kwnames[] = {
52923 (char *) "rowspan",(char *) "colspan", NULL
52924 };
52925
52926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52927 if (obj0) {
52928 ecode1 = SWIG_AsVal_int(obj0, &val1);
52929 if (!SWIG_IsOK(ecode1)) {
52930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52931 }
52932 arg1 = static_cast< int >(val1);
52933 }
52934 if (obj1) {
52935 ecode2 = SWIG_AsVal_int(obj1, &val2);
52936 if (!SWIG_IsOK(ecode2)) {
52937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52938 }
52939 arg2 = static_cast< int >(val2);
52940 }
52941 {
52942 PyThreadState* __tstate = wxPyBeginAllowThreads();
52943 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52944 wxPyEndAllowThreads(__tstate);
52945 if (PyErr_Occurred()) SWIG_fail;
52946 }
52947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52948 return resultobj;
52949 fail:
52950 return NULL;
52951 }
52952
52953
52954 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52955 PyObject *resultobj = 0;
52956 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52957 void *argp1 = 0 ;
52958 int res1 = 0 ;
52959 PyObject *swig_obj[1] ;
52960
52961 if (!args) SWIG_fail;
52962 swig_obj[0] = args;
52963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52964 if (!SWIG_IsOK(res1)) {
52965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52966 }
52967 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52968 {
52969 PyThreadState* __tstate = wxPyBeginAllowThreads();
52970 delete arg1;
52971
52972 wxPyEndAllowThreads(__tstate);
52973 if (PyErr_Occurred()) SWIG_fail;
52974 }
52975 resultobj = SWIG_Py_Void();
52976 return resultobj;
52977 fail:
52978 return NULL;
52979 }
52980
52981
52982 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52983 PyObject *resultobj = 0;
52984 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52985 int result;
52986 void *argp1 = 0 ;
52987 int res1 = 0 ;
52988 PyObject *swig_obj[1] ;
52989
52990 if (!args) SWIG_fail;
52991 swig_obj[0] = args;
52992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52993 if (!SWIG_IsOK(res1)) {
52994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52995 }
52996 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52997 {
52998 PyThreadState* __tstate = wxPyBeginAllowThreads();
52999 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53000 wxPyEndAllowThreads(__tstate);
53001 if (PyErr_Occurred()) SWIG_fail;
53002 }
53003 resultobj = SWIG_From_int(static_cast< int >(result));
53004 return resultobj;
53005 fail:
53006 return NULL;
53007 }
53008
53009
53010 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53011 PyObject *resultobj = 0;
53012 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53013 int result;
53014 void *argp1 = 0 ;
53015 int res1 = 0 ;
53016 PyObject *swig_obj[1] ;
53017
53018 if (!args) SWIG_fail;
53019 swig_obj[0] = args;
53020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53021 if (!SWIG_IsOK(res1)) {
53022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53023 }
53024 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53025 {
53026 PyThreadState* __tstate = wxPyBeginAllowThreads();
53027 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53028 wxPyEndAllowThreads(__tstate);
53029 if (PyErr_Occurred()) SWIG_fail;
53030 }
53031 resultobj = SWIG_From_int(static_cast< int >(result));
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53039 PyObject *resultobj = 0;
53040 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53041 int arg2 ;
53042 void *argp1 = 0 ;
53043 int res1 = 0 ;
53044 int val2 ;
53045 int ecode2 = 0 ;
53046 PyObject * obj0 = 0 ;
53047 PyObject * obj1 = 0 ;
53048 char * kwnames[] = {
53049 (char *) "self",(char *) "rowspan", NULL
53050 };
53051
53052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53054 if (!SWIG_IsOK(res1)) {
53055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53056 }
53057 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53058 ecode2 = SWIG_AsVal_int(obj1, &val2);
53059 if (!SWIG_IsOK(ecode2)) {
53060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53061 }
53062 arg2 = static_cast< int >(val2);
53063 {
53064 PyThreadState* __tstate = wxPyBeginAllowThreads();
53065 (arg1)->SetRowspan(arg2);
53066 wxPyEndAllowThreads(__tstate);
53067 if (PyErr_Occurred()) SWIG_fail;
53068 }
53069 resultobj = SWIG_Py_Void();
53070 return resultobj;
53071 fail:
53072 return NULL;
53073 }
53074
53075
53076 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53077 PyObject *resultobj = 0;
53078 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53079 int arg2 ;
53080 void *argp1 = 0 ;
53081 int res1 = 0 ;
53082 int val2 ;
53083 int ecode2 = 0 ;
53084 PyObject * obj0 = 0 ;
53085 PyObject * obj1 = 0 ;
53086 char * kwnames[] = {
53087 (char *) "self",(char *) "colspan", NULL
53088 };
53089
53090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53092 if (!SWIG_IsOK(res1)) {
53093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53094 }
53095 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53096 ecode2 = SWIG_AsVal_int(obj1, &val2);
53097 if (!SWIG_IsOK(ecode2)) {
53098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53099 }
53100 arg2 = static_cast< int >(val2);
53101 {
53102 PyThreadState* __tstate = wxPyBeginAllowThreads();
53103 (arg1)->SetColspan(arg2);
53104 wxPyEndAllowThreads(__tstate);
53105 if (PyErr_Occurred()) SWIG_fail;
53106 }
53107 resultobj = SWIG_Py_Void();
53108 return resultobj;
53109 fail:
53110 return NULL;
53111 }
53112
53113
53114 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53115 PyObject *resultobj = 0;
53116 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53117 PyObject *arg2 = (PyObject *) 0 ;
53118 bool result;
53119 void *argp1 = 0 ;
53120 int res1 = 0 ;
53121 PyObject * obj0 = 0 ;
53122 PyObject * obj1 = 0 ;
53123 char * kwnames[] = {
53124 (char *) "self",(char *) "other", NULL
53125 };
53126
53127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53129 if (!SWIG_IsOK(res1)) {
53130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53131 }
53132 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53133 arg2 = obj1;
53134 {
53135 result = (bool)wxGBSpan___eq__(arg1,arg2);
53136 if (PyErr_Occurred()) SWIG_fail;
53137 }
53138 {
53139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53140 }
53141 return resultobj;
53142 fail:
53143 return NULL;
53144 }
53145
53146
53147 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53148 PyObject *resultobj = 0;
53149 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53150 PyObject *arg2 = (PyObject *) 0 ;
53151 bool result;
53152 void *argp1 = 0 ;
53153 int res1 = 0 ;
53154 PyObject * obj0 = 0 ;
53155 PyObject * obj1 = 0 ;
53156 char * kwnames[] = {
53157 (char *) "self",(char *) "other", NULL
53158 };
53159
53160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53162 if (!SWIG_IsOK(res1)) {
53163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53164 }
53165 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53166 arg2 = obj1;
53167 {
53168 result = (bool)wxGBSpan___ne__(arg1,arg2);
53169 if (PyErr_Occurred()) SWIG_fail;
53170 }
53171 {
53172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53173 }
53174 return resultobj;
53175 fail:
53176 return NULL;
53177 }
53178
53179
53180 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53181 PyObject *resultobj = 0;
53182 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53183 int arg2 = (int) 1 ;
53184 int arg3 = (int) 1 ;
53185 void *argp1 = 0 ;
53186 int res1 = 0 ;
53187 int val2 ;
53188 int ecode2 = 0 ;
53189 int val3 ;
53190 int ecode3 = 0 ;
53191 PyObject * obj0 = 0 ;
53192 PyObject * obj1 = 0 ;
53193 PyObject * obj2 = 0 ;
53194 char * kwnames[] = {
53195 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53196 };
53197
53198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53200 if (!SWIG_IsOK(res1)) {
53201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53202 }
53203 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53204 if (obj1) {
53205 ecode2 = SWIG_AsVal_int(obj1, &val2);
53206 if (!SWIG_IsOK(ecode2)) {
53207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53208 }
53209 arg2 = static_cast< int >(val2);
53210 }
53211 if (obj2) {
53212 ecode3 = SWIG_AsVal_int(obj2, &val3);
53213 if (!SWIG_IsOK(ecode3)) {
53214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53215 }
53216 arg3 = static_cast< int >(val3);
53217 }
53218 {
53219 PyThreadState* __tstate = wxPyBeginAllowThreads();
53220 wxGBSpan_Set(arg1,arg2,arg3);
53221 wxPyEndAllowThreads(__tstate);
53222 if (PyErr_Occurred()) SWIG_fail;
53223 }
53224 resultobj = SWIG_Py_Void();
53225 return resultobj;
53226 fail:
53227 return NULL;
53228 }
53229
53230
53231 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53232 PyObject *resultobj = 0;
53233 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53234 PyObject *result = 0 ;
53235 void *argp1 = 0 ;
53236 int res1 = 0 ;
53237 PyObject *swig_obj[1] ;
53238
53239 if (!args) SWIG_fail;
53240 swig_obj[0] = args;
53241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53242 if (!SWIG_IsOK(res1)) {
53243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53244 }
53245 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53246 {
53247 PyThreadState* __tstate = wxPyBeginAllowThreads();
53248 result = (PyObject *)wxGBSpan_Get(arg1);
53249 wxPyEndAllowThreads(__tstate);
53250 if (PyErr_Occurred()) SWIG_fail;
53251 }
53252 resultobj = result;
53253 return resultobj;
53254 fail:
53255 return NULL;
53256 }
53257
53258
53259 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53260 PyObject *obj;
53261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53262 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53263 return SWIG_Py_Void();
53264 }
53265
53266 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53267 return SWIG_Python_InitShadowInstance(args);
53268 }
53269
53270 SWIGINTERN int DefaultSpan_set(PyObject *) {
53271 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53272 return 1;
53273 }
53274
53275
53276 SWIGINTERN PyObject *DefaultSpan_get(void) {
53277 PyObject *pyobj = 0;
53278
53279 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53280 return pyobj;
53281 }
53282
53283
53284 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53285 PyObject *resultobj = 0;
53286 wxGBSizerItem *result = 0 ;
53287
53288 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53289 {
53290 PyThreadState* __tstate = wxPyBeginAllowThreads();
53291 result = (wxGBSizerItem *)new wxGBSizerItem();
53292 wxPyEndAllowThreads(__tstate);
53293 if (PyErr_Occurred()) SWIG_fail;
53294 }
53295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53296 return resultobj;
53297 fail:
53298 return NULL;
53299 }
53300
53301
53302 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53303 PyObject *resultobj = 0;
53304 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53305 void *argp1 = 0 ;
53306 int res1 = 0 ;
53307 PyObject *swig_obj[1] ;
53308
53309 if (!args) SWIG_fail;
53310 swig_obj[0] = args;
53311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53312 if (!SWIG_IsOK(res1)) {
53313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53314 }
53315 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53316 {
53317 PyThreadState* __tstate = wxPyBeginAllowThreads();
53318 delete arg1;
53319
53320 wxPyEndAllowThreads(__tstate);
53321 if (PyErr_Occurred()) SWIG_fail;
53322 }
53323 resultobj = SWIG_Py_Void();
53324 return resultobj;
53325 fail:
53326 return NULL;
53327 }
53328
53329
53330 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53331 PyObject *resultobj = 0;
53332 wxWindow *arg1 = (wxWindow *) 0 ;
53333 wxGBPosition *arg2 = 0 ;
53334 wxGBSpan *arg3 = 0 ;
53335 int arg4 ;
53336 int arg5 ;
53337 PyObject *arg6 = (PyObject *) NULL ;
53338 wxGBSizerItem *result = 0 ;
53339 void *argp1 = 0 ;
53340 int res1 = 0 ;
53341 wxGBPosition temp2 ;
53342 wxGBSpan temp3 ;
53343 int val4 ;
53344 int ecode4 = 0 ;
53345 int val5 ;
53346 int ecode5 = 0 ;
53347 PyObject * obj0 = 0 ;
53348 PyObject * obj1 = 0 ;
53349 PyObject * obj2 = 0 ;
53350 PyObject * obj3 = 0 ;
53351 PyObject * obj4 = 0 ;
53352 PyObject * obj5 = 0 ;
53353 char * kwnames[] = {
53354 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53355 };
53356
53357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53359 if (!SWIG_IsOK(res1)) {
53360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53361 }
53362 arg1 = reinterpret_cast< wxWindow * >(argp1);
53363 {
53364 arg2 = &temp2;
53365 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53366 }
53367 {
53368 arg3 = &temp3;
53369 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53370 }
53371 ecode4 = SWIG_AsVal_int(obj3, &val4);
53372 if (!SWIG_IsOK(ecode4)) {
53373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53374 }
53375 arg4 = static_cast< int >(val4);
53376 ecode5 = SWIG_AsVal_int(obj4, &val5);
53377 if (!SWIG_IsOK(ecode5)) {
53378 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53379 }
53380 arg5 = static_cast< int >(val5);
53381 if (obj5) {
53382 arg6 = obj5;
53383 }
53384 {
53385 PyThreadState* __tstate = wxPyBeginAllowThreads();
53386 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53387 wxPyEndAllowThreads(__tstate);
53388 if (PyErr_Occurred()) SWIG_fail;
53389 }
53390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53391 return resultobj;
53392 fail:
53393 return NULL;
53394 }
53395
53396
53397 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53398 PyObject *resultobj = 0;
53399 wxSizer *arg1 = (wxSizer *) 0 ;
53400 wxGBPosition *arg2 = 0 ;
53401 wxGBSpan *arg3 = 0 ;
53402 int arg4 ;
53403 int arg5 ;
53404 PyObject *arg6 = (PyObject *) NULL ;
53405 wxGBSizerItem *result = 0 ;
53406 int res1 = 0 ;
53407 wxGBPosition temp2 ;
53408 wxGBSpan temp3 ;
53409 int val4 ;
53410 int ecode4 = 0 ;
53411 int val5 ;
53412 int ecode5 = 0 ;
53413 PyObject * obj0 = 0 ;
53414 PyObject * obj1 = 0 ;
53415 PyObject * obj2 = 0 ;
53416 PyObject * obj3 = 0 ;
53417 PyObject * obj4 = 0 ;
53418 PyObject * obj5 = 0 ;
53419 char * kwnames[] = {
53420 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53421 };
53422
53423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53424 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53425 if (!SWIG_IsOK(res1)) {
53426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53427 }
53428 {
53429 arg2 = &temp2;
53430 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53431 }
53432 {
53433 arg3 = &temp3;
53434 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53435 }
53436 ecode4 = SWIG_AsVal_int(obj3, &val4);
53437 if (!SWIG_IsOK(ecode4)) {
53438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53439 }
53440 arg4 = static_cast< int >(val4);
53441 ecode5 = SWIG_AsVal_int(obj4, &val5);
53442 if (!SWIG_IsOK(ecode5)) {
53443 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53444 }
53445 arg5 = static_cast< int >(val5);
53446 if (obj5) {
53447 arg6 = obj5;
53448 }
53449 {
53450 PyThreadState* __tstate = wxPyBeginAllowThreads();
53451 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53452 wxPyEndAllowThreads(__tstate);
53453 if (PyErr_Occurred()) SWIG_fail;
53454 }
53455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53456 return resultobj;
53457 fail:
53458 return NULL;
53459 }
53460
53461
53462 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53463 PyObject *resultobj = 0;
53464 int arg1 ;
53465 int arg2 ;
53466 wxGBPosition *arg3 = 0 ;
53467 wxGBSpan *arg4 = 0 ;
53468 int arg5 ;
53469 int arg6 ;
53470 PyObject *arg7 = (PyObject *) NULL ;
53471 wxGBSizerItem *result = 0 ;
53472 int val1 ;
53473 int ecode1 = 0 ;
53474 int val2 ;
53475 int ecode2 = 0 ;
53476 wxGBPosition temp3 ;
53477 wxGBSpan temp4 ;
53478 int val5 ;
53479 int ecode5 = 0 ;
53480 int val6 ;
53481 int ecode6 = 0 ;
53482 PyObject * obj0 = 0 ;
53483 PyObject * obj1 = 0 ;
53484 PyObject * obj2 = 0 ;
53485 PyObject * obj3 = 0 ;
53486 PyObject * obj4 = 0 ;
53487 PyObject * obj5 = 0 ;
53488 PyObject * obj6 = 0 ;
53489 char * kwnames[] = {
53490 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53491 };
53492
53493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53494 ecode1 = SWIG_AsVal_int(obj0, &val1);
53495 if (!SWIG_IsOK(ecode1)) {
53496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53497 }
53498 arg1 = static_cast< int >(val1);
53499 ecode2 = SWIG_AsVal_int(obj1, &val2);
53500 if (!SWIG_IsOK(ecode2)) {
53501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53502 }
53503 arg2 = static_cast< int >(val2);
53504 {
53505 arg3 = &temp3;
53506 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53507 }
53508 {
53509 arg4 = &temp4;
53510 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53511 }
53512 ecode5 = SWIG_AsVal_int(obj4, &val5);
53513 if (!SWIG_IsOK(ecode5)) {
53514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53515 }
53516 arg5 = static_cast< int >(val5);
53517 ecode6 = SWIG_AsVal_int(obj5, &val6);
53518 if (!SWIG_IsOK(ecode6)) {
53519 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53520 }
53521 arg6 = static_cast< int >(val6);
53522 if (obj6) {
53523 arg7 = obj6;
53524 }
53525 {
53526 PyThreadState* __tstate = wxPyBeginAllowThreads();
53527 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53528 wxPyEndAllowThreads(__tstate);
53529 if (PyErr_Occurred()) SWIG_fail;
53530 }
53531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53532 return resultobj;
53533 fail:
53534 return NULL;
53535 }
53536
53537
53538 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53539 PyObject *resultobj = 0;
53540 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53541 wxGBPosition result;
53542 void *argp1 = 0 ;
53543 int res1 = 0 ;
53544 PyObject *swig_obj[1] ;
53545
53546 if (!args) SWIG_fail;
53547 swig_obj[0] = args;
53548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53549 if (!SWIG_IsOK(res1)) {
53550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53551 }
53552 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53553 {
53554 PyThreadState* __tstate = wxPyBeginAllowThreads();
53555 result = ((wxGBSizerItem const *)arg1)->GetPos();
53556 wxPyEndAllowThreads(__tstate);
53557 if (PyErr_Occurred()) SWIG_fail;
53558 }
53559 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53560 return resultobj;
53561 fail:
53562 return NULL;
53563 }
53564
53565
53566 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53567 PyObject *resultobj = 0;
53568 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53569 wxGBSpan result;
53570 void *argp1 = 0 ;
53571 int res1 = 0 ;
53572 PyObject *swig_obj[1] ;
53573
53574 if (!args) SWIG_fail;
53575 swig_obj[0] = args;
53576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53577 if (!SWIG_IsOK(res1)) {
53578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53579 }
53580 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53581 {
53582 PyThreadState* __tstate = wxPyBeginAllowThreads();
53583 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53584 wxPyEndAllowThreads(__tstate);
53585 if (PyErr_Occurred()) SWIG_fail;
53586 }
53587 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53588 return resultobj;
53589 fail:
53590 return NULL;
53591 }
53592
53593
53594 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53595 PyObject *resultobj = 0;
53596 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53597 wxGBPosition *arg2 = 0 ;
53598 bool result;
53599 void *argp1 = 0 ;
53600 int res1 = 0 ;
53601 wxGBPosition temp2 ;
53602 PyObject * obj0 = 0 ;
53603 PyObject * obj1 = 0 ;
53604 char * kwnames[] = {
53605 (char *) "self",(char *) "pos", NULL
53606 };
53607
53608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53610 if (!SWIG_IsOK(res1)) {
53611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53612 }
53613 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53614 {
53615 arg2 = &temp2;
53616 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53617 }
53618 {
53619 PyThreadState* __tstate = wxPyBeginAllowThreads();
53620 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53621 wxPyEndAllowThreads(__tstate);
53622 if (PyErr_Occurred()) SWIG_fail;
53623 }
53624 {
53625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53626 }
53627 return resultobj;
53628 fail:
53629 return NULL;
53630 }
53631
53632
53633 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53634 PyObject *resultobj = 0;
53635 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53636 wxGBSpan *arg2 = 0 ;
53637 bool result;
53638 void *argp1 = 0 ;
53639 int res1 = 0 ;
53640 wxGBSpan temp2 ;
53641 PyObject * obj0 = 0 ;
53642 PyObject * obj1 = 0 ;
53643 char * kwnames[] = {
53644 (char *) "self",(char *) "span", NULL
53645 };
53646
53647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53649 if (!SWIG_IsOK(res1)) {
53650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53651 }
53652 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53653 {
53654 arg2 = &temp2;
53655 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53656 }
53657 {
53658 PyThreadState* __tstate = wxPyBeginAllowThreads();
53659 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53660 wxPyEndAllowThreads(__tstate);
53661 if (PyErr_Occurred()) SWIG_fail;
53662 }
53663 {
53664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53665 }
53666 return resultobj;
53667 fail:
53668 return NULL;
53669 }
53670
53671
53672 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53673 PyObject *resultobj = 0;
53674 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53675 wxGBSizerItem *arg2 = 0 ;
53676 bool result;
53677 void *argp1 = 0 ;
53678 int res1 = 0 ;
53679 void *argp2 = 0 ;
53680 int res2 = 0 ;
53681 PyObject * obj0 = 0 ;
53682 PyObject * obj1 = 0 ;
53683 char * kwnames[] = {
53684 (char *) "self",(char *) "other", NULL
53685 };
53686
53687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53689 if (!SWIG_IsOK(res1)) {
53690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53691 }
53692 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53694 if (!SWIG_IsOK(res2)) {
53695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53696 }
53697 if (!argp2) {
53698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53699 }
53700 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53701 {
53702 PyThreadState* __tstate = wxPyBeginAllowThreads();
53703 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53704 wxPyEndAllowThreads(__tstate);
53705 if (PyErr_Occurred()) SWIG_fail;
53706 }
53707 {
53708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53709 }
53710 return resultobj;
53711 fail:
53712 return NULL;
53713 }
53714
53715
53716 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53717 PyObject *resultobj = 0;
53718 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53719 wxGBPosition *arg2 = 0 ;
53720 wxGBSpan *arg3 = 0 ;
53721 bool result;
53722 void *argp1 = 0 ;
53723 int res1 = 0 ;
53724 wxGBPosition temp2 ;
53725 wxGBSpan temp3 ;
53726 PyObject * obj0 = 0 ;
53727 PyObject * obj1 = 0 ;
53728 PyObject * obj2 = 0 ;
53729 char * kwnames[] = {
53730 (char *) "self",(char *) "pos",(char *) "span", NULL
53731 };
53732
53733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53735 if (!SWIG_IsOK(res1)) {
53736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53737 }
53738 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53739 {
53740 arg2 = &temp2;
53741 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53742 }
53743 {
53744 arg3 = &temp3;
53745 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53746 }
53747 {
53748 PyThreadState* __tstate = wxPyBeginAllowThreads();
53749 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53750 wxPyEndAllowThreads(__tstate);
53751 if (PyErr_Occurred()) SWIG_fail;
53752 }
53753 {
53754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53755 }
53756 return resultobj;
53757 fail:
53758 return NULL;
53759 }
53760
53761
53762 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53763 PyObject *resultobj = 0;
53764 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53765 wxGBPosition result;
53766 void *argp1 = 0 ;
53767 int res1 = 0 ;
53768 PyObject *swig_obj[1] ;
53769
53770 if (!args) SWIG_fail;
53771 swig_obj[0] = args;
53772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53773 if (!SWIG_IsOK(res1)) {
53774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53775 }
53776 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53777 {
53778 PyThreadState* __tstate = wxPyBeginAllowThreads();
53779 result = wxGBSizerItem_GetEndPos(arg1);
53780 wxPyEndAllowThreads(__tstate);
53781 if (PyErr_Occurred()) SWIG_fail;
53782 }
53783 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53784 return resultobj;
53785 fail:
53786 return NULL;
53787 }
53788
53789
53790 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53791 PyObject *resultobj = 0;
53792 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53793 wxGridBagSizer *result = 0 ;
53794 void *argp1 = 0 ;
53795 int res1 = 0 ;
53796 PyObject *swig_obj[1] ;
53797
53798 if (!args) SWIG_fail;
53799 swig_obj[0] = args;
53800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53801 if (!SWIG_IsOK(res1)) {
53802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53803 }
53804 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53805 {
53806 PyThreadState* __tstate = wxPyBeginAllowThreads();
53807 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53808 wxPyEndAllowThreads(__tstate);
53809 if (PyErr_Occurred()) SWIG_fail;
53810 }
53811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53812 return resultobj;
53813 fail:
53814 return NULL;
53815 }
53816
53817
53818 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53819 PyObject *resultobj = 0;
53820 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53821 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53822 void *argp1 = 0 ;
53823 int res1 = 0 ;
53824 void *argp2 = 0 ;
53825 int res2 = 0 ;
53826 PyObject * obj0 = 0 ;
53827 PyObject * obj1 = 0 ;
53828 char * kwnames[] = {
53829 (char *) "self",(char *) "sizer", NULL
53830 };
53831
53832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53834 if (!SWIG_IsOK(res1)) {
53835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53836 }
53837 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53839 if (!SWIG_IsOK(res2)) {
53840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53841 }
53842 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53843 {
53844 PyThreadState* __tstate = wxPyBeginAllowThreads();
53845 (arg1)->SetGBSizer(arg2);
53846 wxPyEndAllowThreads(__tstate);
53847 if (PyErr_Occurred()) SWIG_fail;
53848 }
53849 resultobj = SWIG_Py_Void();
53850 return resultobj;
53851 fail:
53852 return NULL;
53853 }
53854
53855
53856 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53857 PyObject *obj;
53858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53859 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53860 return SWIG_Py_Void();
53861 }
53862
53863 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53864 return SWIG_Python_InitShadowInstance(args);
53865 }
53866
53867 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53868 PyObject *resultobj = 0;
53869 int arg1 = (int) 0 ;
53870 int arg2 = (int) 0 ;
53871 wxGridBagSizer *result = 0 ;
53872 int val1 ;
53873 int ecode1 = 0 ;
53874 int val2 ;
53875 int ecode2 = 0 ;
53876 PyObject * obj0 = 0 ;
53877 PyObject * obj1 = 0 ;
53878 char * kwnames[] = {
53879 (char *) "vgap",(char *) "hgap", NULL
53880 };
53881
53882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53883 if (obj0) {
53884 ecode1 = SWIG_AsVal_int(obj0, &val1);
53885 if (!SWIG_IsOK(ecode1)) {
53886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53887 }
53888 arg1 = static_cast< int >(val1);
53889 }
53890 if (obj1) {
53891 ecode2 = SWIG_AsVal_int(obj1, &val2);
53892 if (!SWIG_IsOK(ecode2)) {
53893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53894 }
53895 arg2 = static_cast< int >(val2);
53896 }
53897 {
53898 PyThreadState* __tstate = wxPyBeginAllowThreads();
53899 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53900 wxPyEndAllowThreads(__tstate);
53901 if (PyErr_Occurred()) SWIG_fail;
53902 }
53903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53904 return resultobj;
53905 fail:
53906 return NULL;
53907 }
53908
53909
53910 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53911 PyObject *resultobj = 0;
53912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53913 PyObject *arg2 = (PyObject *) 0 ;
53914 wxGBPosition *arg3 = 0 ;
53915 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53916 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53917 int arg5 = (int) 0 ;
53918 int arg6 = (int) 0 ;
53919 PyObject *arg7 = (PyObject *) NULL ;
53920 wxGBSizerItem *result = 0 ;
53921 void *argp1 = 0 ;
53922 int res1 = 0 ;
53923 wxGBPosition temp3 ;
53924 wxGBSpan temp4 ;
53925 int val5 ;
53926 int ecode5 = 0 ;
53927 int val6 ;
53928 int ecode6 = 0 ;
53929 PyObject * obj0 = 0 ;
53930 PyObject * obj1 = 0 ;
53931 PyObject * obj2 = 0 ;
53932 PyObject * obj3 = 0 ;
53933 PyObject * obj4 = 0 ;
53934 PyObject * obj5 = 0 ;
53935 PyObject * obj6 = 0 ;
53936 char * kwnames[] = {
53937 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53938 };
53939
53940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53942 if (!SWIG_IsOK(res1)) {
53943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53944 }
53945 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53946 arg2 = obj1;
53947 {
53948 arg3 = &temp3;
53949 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53950 }
53951 if (obj3) {
53952 {
53953 arg4 = &temp4;
53954 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53955 }
53956 }
53957 if (obj4) {
53958 ecode5 = SWIG_AsVal_int(obj4, &val5);
53959 if (!SWIG_IsOK(ecode5)) {
53960 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53961 }
53962 arg5 = static_cast< int >(val5);
53963 }
53964 if (obj5) {
53965 ecode6 = SWIG_AsVal_int(obj5, &val6);
53966 if (!SWIG_IsOK(ecode6)) {
53967 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53968 }
53969 arg6 = static_cast< int >(val6);
53970 }
53971 if (obj6) {
53972 arg7 = obj6;
53973 }
53974 {
53975 PyThreadState* __tstate = wxPyBeginAllowThreads();
53976 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53977 wxPyEndAllowThreads(__tstate);
53978 if (PyErr_Occurred()) SWIG_fail;
53979 }
53980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53981 return resultobj;
53982 fail:
53983 return NULL;
53984 }
53985
53986
53987 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53988 PyObject *resultobj = 0;
53989 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53990 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53991 wxGBSizerItem *result = 0 ;
53992 void *argp1 = 0 ;
53993 int res1 = 0 ;
53994 int res2 = 0 ;
53995 PyObject * obj0 = 0 ;
53996 PyObject * obj1 = 0 ;
53997 char * kwnames[] = {
53998 (char *) "self",(char *) "item", NULL
53999 };
54000
54001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54003 if (!SWIG_IsOK(res1)) {
54004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54005 }
54006 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54007 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54008 if (!SWIG_IsOK(res2)) {
54009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54010 }
54011 {
54012 PyThreadState* __tstate = wxPyBeginAllowThreads();
54013 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54014 wxPyEndAllowThreads(__tstate);
54015 if (PyErr_Occurred()) SWIG_fail;
54016 }
54017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54018 return resultobj;
54019 fail:
54020 return NULL;
54021 }
54022
54023
54024 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54025 PyObject *resultobj = 0;
54026 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54027 int arg2 ;
54028 int arg3 ;
54029 wxSize result;
54030 void *argp1 = 0 ;
54031 int res1 = 0 ;
54032 int val2 ;
54033 int ecode2 = 0 ;
54034 int val3 ;
54035 int ecode3 = 0 ;
54036 PyObject * obj0 = 0 ;
54037 PyObject * obj1 = 0 ;
54038 PyObject * obj2 = 0 ;
54039 char * kwnames[] = {
54040 (char *) "self",(char *) "row",(char *) "col", NULL
54041 };
54042
54043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54045 if (!SWIG_IsOK(res1)) {
54046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54047 }
54048 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54049 ecode2 = SWIG_AsVal_int(obj1, &val2);
54050 if (!SWIG_IsOK(ecode2)) {
54051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54052 }
54053 arg2 = static_cast< int >(val2);
54054 ecode3 = SWIG_AsVal_int(obj2, &val3);
54055 if (!SWIG_IsOK(ecode3)) {
54056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54057 }
54058 arg3 = static_cast< int >(val3);
54059 {
54060 PyThreadState* __tstate = wxPyBeginAllowThreads();
54061 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54062 wxPyEndAllowThreads(__tstate);
54063 if (PyErr_Occurred()) SWIG_fail;
54064 }
54065 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54066 return resultobj;
54067 fail:
54068 return NULL;
54069 }
54070
54071
54072 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54073 PyObject *resultobj = 0;
54074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54075 wxSize result;
54076 void *argp1 = 0 ;
54077 int res1 = 0 ;
54078 PyObject *swig_obj[1] ;
54079
54080 if (!args) SWIG_fail;
54081 swig_obj[0] = args;
54082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54083 if (!SWIG_IsOK(res1)) {
54084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54085 }
54086 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54087 {
54088 PyThreadState* __tstate = wxPyBeginAllowThreads();
54089 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54090 wxPyEndAllowThreads(__tstate);
54091 if (PyErr_Occurred()) SWIG_fail;
54092 }
54093 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54094 return resultobj;
54095 fail:
54096 return NULL;
54097 }
54098
54099
54100 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54101 PyObject *resultobj = 0;
54102 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54103 wxSize *arg2 = 0 ;
54104 void *argp1 = 0 ;
54105 int res1 = 0 ;
54106 wxSize temp2 ;
54107 PyObject * obj0 = 0 ;
54108 PyObject * obj1 = 0 ;
54109 char * kwnames[] = {
54110 (char *) "self",(char *) "sz", NULL
54111 };
54112
54113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54115 if (!SWIG_IsOK(res1)) {
54116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54117 }
54118 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54119 {
54120 arg2 = &temp2;
54121 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54122 }
54123 {
54124 PyThreadState* __tstate = wxPyBeginAllowThreads();
54125 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54126 wxPyEndAllowThreads(__tstate);
54127 if (PyErr_Occurred()) SWIG_fail;
54128 }
54129 resultobj = SWIG_Py_Void();
54130 return resultobj;
54131 fail:
54132 return NULL;
54133 }
54134
54135
54136 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54137 PyObject *resultobj = 0;
54138 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54139 wxWindow *arg2 = (wxWindow *) 0 ;
54140 wxGBPosition result;
54141 void *argp1 = 0 ;
54142 int res1 = 0 ;
54143 void *argp2 = 0 ;
54144 int res2 = 0 ;
54145
54146 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54148 if (!SWIG_IsOK(res1)) {
54149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54150 }
54151 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54152 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54153 if (!SWIG_IsOK(res2)) {
54154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54155 }
54156 arg2 = reinterpret_cast< wxWindow * >(argp2);
54157 {
54158 PyThreadState* __tstate = wxPyBeginAllowThreads();
54159 result = (arg1)->GetItemPosition(arg2);
54160 wxPyEndAllowThreads(__tstate);
54161 if (PyErr_Occurred()) SWIG_fail;
54162 }
54163 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54164 return resultobj;
54165 fail:
54166 return NULL;
54167 }
54168
54169
54170 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54171 PyObject *resultobj = 0;
54172 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54173 wxSizer *arg2 = (wxSizer *) 0 ;
54174 wxGBPosition result;
54175 void *argp1 = 0 ;
54176 int res1 = 0 ;
54177 void *argp2 = 0 ;
54178 int res2 = 0 ;
54179
54180 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54182 if (!SWIG_IsOK(res1)) {
54183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54184 }
54185 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54186 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54187 if (!SWIG_IsOK(res2)) {
54188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54189 }
54190 arg2 = reinterpret_cast< wxSizer * >(argp2);
54191 {
54192 PyThreadState* __tstate = wxPyBeginAllowThreads();
54193 result = (arg1)->GetItemPosition(arg2);
54194 wxPyEndAllowThreads(__tstate);
54195 if (PyErr_Occurred()) SWIG_fail;
54196 }
54197 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54198 return resultobj;
54199 fail:
54200 return NULL;
54201 }
54202
54203
54204 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54205 PyObject *resultobj = 0;
54206 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54207 size_t arg2 ;
54208 wxGBPosition result;
54209 void *argp1 = 0 ;
54210 int res1 = 0 ;
54211 size_t val2 ;
54212 int ecode2 = 0 ;
54213
54214 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54216 if (!SWIG_IsOK(res1)) {
54217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54218 }
54219 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54220 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54221 if (!SWIG_IsOK(ecode2)) {
54222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54223 }
54224 arg2 = static_cast< size_t >(val2);
54225 {
54226 PyThreadState* __tstate = wxPyBeginAllowThreads();
54227 result = (arg1)->GetItemPosition(arg2);
54228 wxPyEndAllowThreads(__tstate);
54229 if (PyErr_Occurred()) SWIG_fail;
54230 }
54231 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54232 return resultobj;
54233 fail:
54234 return NULL;
54235 }
54236
54237
54238 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54239 int argc;
54240 PyObject *argv[3];
54241
54242 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54243 --argc;
54244 if (argc == 2) {
54245 int _v = 0;
54246 {
54247 void *vptr = 0;
54248 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54249 _v = SWIG_CheckState(res);
54250 }
54251 if (!_v) goto check_1;
54252 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54253 }
54254 check_1:
54255
54256 if (argc == 2) {
54257 int _v = 0;
54258 {
54259 void *vptr = 0;
54260 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54261 _v = SWIG_CheckState(res);
54262 }
54263 if (!_v) goto check_2;
54264 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54265 }
54266 check_2:
54267
54268 if (argc == 2) {
54269 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54270 }
54271
54272 fail:
54273 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54274 return NULL;
54275 }
54276
54277
54278 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54279 PyObject *resultobj = 0;
54280 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54281 wxWindow *arg2 = (wxWindow *) 0 ;
54282 wxGBPosition *arg3 = 0 ;
54283 bool result;
54284 void *argp1 = 0 ;
54285 int res1 = 0 ;
54286 void *argp2 = 0 ;
54287 int res2 = 0 ;
54288 wxGBPosition temp3 ;
54289
54290 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54292 if (!SWIG_IsOK(res1)) {
54293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54294 }
54295 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54296 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54297 if (!SWIG_IsOK(res2)) {
54298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54299 }
54300 arg2 = reinterpret_cast< wxWindow * >(argp2);
54301 {
54302 arg3 = &temp3;
54303 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54304 }
54305 {
54306 PyThreadState* __tstate = wxPyBeginAllowThreads();
54307 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54308 wxPyEndAllowThreads(__tstate);
54309 if (PyErr_Occurred()) SWIG_fail;
54310 }
54311 {
54312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54313 }
54314 return resultobj;
54315 fail:
54316 return NULL;
54317 }
54318
54319
54320 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54321 PyObject *resultobj = 0;
54322 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54323 wxSizer *arg2 = (wxSizer *) 0 ;
54324 wxGBPosition *arg3 = 0 ;
54325 bool result;
54326 void *argp1 = 0 ;
54327 int res1 = 0 ;
54328 void *argp2 = 0 ;
54329 int res2 = 0 ;
54330 wxGBPosition temp3 ;
54331
54332 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54334 if (!SWIG_IsOK(res1)) {
54335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54336 }
54337 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54338 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54339 if (!SWIG_IsOK(res2)) {
54340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54341 }
54342 arg2 = reinterpret_cast< wxSizer * >(argp2);
54343 {
54344 arg3 = &temp3;
54345 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54346 }
54347 {
54348 PyThreadState* __tstate = wxPyBeginAllowThreads();
54349 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54350 wxPyEndAllowThreads(__tstate);
54351 if (PyErr_Occurred()) SWIG_fail;
54352 }
54353 {
54354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54355 }
54356 return resultobj;
54357 fail:
54358 return NULL;
54359 }
54360
54361
54362 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54363 PyObject *resultobj = 0;
54364 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54365 size_t arg2 ;
54366 wxGBPosition *arg3 = 0 ;
54367 bool result;
54368 void *argp1 = 0 ;
54369 int res1 = 0 ;
54370 size_t val2 ;
54371 int ecode2 = 0 ;
54372 wxGBPosition temp3 ;
54373
54374 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54376 if (!SWIG_IsOK(res1)) {
54377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54378 }
54379 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54380 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54381 if (!SWIG_IsOK(ecode2)) {
54382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54383 }
54384 arg2 = static_cast< size_t >(val2);
54385 {
54386 arg3 = &temp3;
54387 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54388 }
54389 {
54390 PyThreadState* __tstate = wxPyBeginAllowThreads();
54391 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54392 wxPyEndAllowThreads(__tstate);
54393 if (PyErr_Occurred()) SWIG_fail;
54394 }
54395 {
54396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54397 }
54398 return resultobj;
54399 fail:
54400 return NULL;
54401 }
54402
54403
54404 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54405 int argc;
54406 PyObject *argv[4];
54407
54408 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54409 --argc;
54410 if (argc == 3) {
54411 int _v = 0;
54412 {
54413 void *vptr = 0;
54414 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54415 _v = SWIG_CheckState(res);
54416 }
54417 if (!_v) goto check_1;
54418 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54419 }
54420 check_1:
54421
54422 if (argc == 3) {
54423 int _v = 0;
54424 {
54425 void *vptr = 0;
54426 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54427 _v = SWIG_CheckState(res);
54428 }
54429 if (!_v) goto check_2;
54430 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54431 }
54432 check_2:
54433
54434 if (argc == 3) {
54435 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54436 }
54437
54438 fail:
54439 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54440 return NULL;
54441 }
54442
54443
54444 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54445 PyObject *resultobj = 0;
54446 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54447 wxWindow *arg2 = (wxWindow *) 0 ;
54448 wxGBSpan result;
54449 void *argp1 = 0 ;
54450 int res1 = 0 ;
54451 void *argp2 = 0 ;
54452 int res2 = 0 ;
54453
54454 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54456 if (!SWIG_IsOK(res1)) {
54457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54458 }
54459 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54460 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54461 if (!SWIG_IsOK(res2)) {
54462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54463 }
54464 arg2 = reinterpret_cast< wxWindow * >(argp2);
54465 {
54466 PyThreadState* __tstate = wxPyBeginAllowThreads();
54467 result = (arg1)->GetItemSpan(arg2);
54468 wxPyEndAllowThreads(__tstate);
54469 if (PyErr_Occurred()) SWIG_fail;
54470 }
54471 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54472 return resultobj;
54473 fail:
54474 return NULL;
54475 }
54476
54477
54478 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54479 PyObject *resultobj = 0;
54480 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54481 wxSizer *arg2 = (wxSizer *) 0 ;
54482 wxGBSpan result;
54483 void *argp1 = 0 ;
54484 int res1 = 0 ;
54485 void *argp2 = 0 ;
54486 int res2 = 0 ;
54487
54488 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54490 if (!SWIG_IsOK(res1)) {
54491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54492 }
54493 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54494 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54495 if (!SWIG_IsOK(res2)) {
54496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54497 }
54498 arg2 = reinterpret_cast< wxSizer * >(argp2);
54499 {
54500 PyThreadState* __tstate = wxPyBeginAllowThreads();
54501 result = (arg1)->GetItemSpan(arg2);
54502 wxPyEndAllowThreads(__tstate);
54503 if (PyErr_Occurred()) SWIG_fail;
54504 }
54505 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54506 return resultobj;
54507 fail:
54508 return NULL;
54509 }
54510
54511
54512 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54513 PyObject *resultobj = 0;
54514 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54515 size_t arg2 ;
54516 wxGBSpan result;
54517 void *argp1 = 0 ;
54518 int res1 = 0 ;
54519 size_t val2 ;
54520 int ecode2 = 0 ;
54521
54522 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54524 if (!SWIG_IsOK(res1)) {
54525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54526 }
54527 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54528 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54529 if (!SWIG_IsOK(ecode2)) {
54530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54531 }
54532 arg2 = static_cast< size_t >(val2);
54533 {
54534 PyThreadState* __tstate = wxPyBeginAllowThreads();
54535 result = (arg1)->GetItemSpan(arg2);
54536 wxPyEndAllowThreads(__tstate);
54537 if (PyErr_Occurred()) SWIG_fail;
54538 }
54539 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54540 return resultobj;
54541 fail:
54542 return NULL;
54543 }
54544
54545
54546 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54547 int argc;
54548 PyObject *argv[3];
54549
54550 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54551 --argc;
54552 if (argc == 2) {
54553 int _v = 0;
54554 {
54555 void *vptr = 0;
54556 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54557 _v = SWIG_CheckState(res);
54558 }
54559 if (!_v) goto check_1;
54560 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54561 }
54562 check_1:
54563
54564 if (argc == 2) {
54565 int _v = 0;
54566 {
54567 void *vptr = 0;
54568 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54569 _v = SWIG_CheckState(res);
54570 }
54571 if (!_v) goto check_2;
54572 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54573 }
54574 check_2:
54575
54576 if (argc == 2) {
54577 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54578 }
54579
54580 fail:
54581 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54582 return NULL;
54583 }
54584
54585
54586 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54587 PyObject *resultobj = 0;
54588 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54589 wxWindow *arg2 = (wxWindow *) 0 ;
54590 wxGBSpan *arg3 = 0 ;
54591 bool result;
54592 void *argp1 = 0 ;
54593 int res1 = 0 ;
54594 void *argp2 = 0 ;
54595 int res2 = 0 ;
54596 wxGBSpan temp3 ;
54597
54598 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54600 if (!SWIG_IsOK(res1)) {
54601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54602 }
54603 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54604 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54605 if (!SWIG_IsOK(res2)) {
54606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54607 }
54608 arg2 = reinterpret_cast< wxWindow * >(argp2);
54609 {
54610 arg3 = &temp3;
54611 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54612 }
54613 {
54614 PyThreadState* __tstate = wxPyBeginAllowThreads();
54615 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54616 wxPyEndAllowThreads(__tstate);
54617 if (PyErr_Occurred()) SWIG_fail;
54618 }
54619 {
54620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54621 }
54622 return resultobj;
54623 fail:
54624 return NULL;
54625 }
54626
54627
54628 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54629 PyObject *resultobj = 0;
54630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54631 wxSizer *arg2 = (wxSizer *) 0 ;
54632 wxGBSpan *arg3 = 0 ;
54633 bool result;
54634 void *argp1 = 0 ;
54635 int res1 = 0 ;
54636 void *argp2 = 0 ;
54637 int res2 = 0 ;
54638 wxGBSpan temp3 ;
54639
54640 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54642 if (!SWIG_IsOK(res1)) {
54643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54644 }
54645 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54646 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54647 if (!SWIG_IsOK(res2)) {
54648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54649 }
54650 arg2 = reinterpret_cast< wxSizer * >(argp2);
54651 {
54652 arg3 = &temp3;
54653 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54654 }
54655 {
54656 PyThreadState* __tstate = wxPyBeginAllowThreads();
54657 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54658 wxPyEndAllowThreads(__tstate);
54659 if (PyErr_Occurred()) SWIG_fail;
54660 }
54661 {
54662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54663 }
54664 return resultobj;
54665 fail:
54666 return NULL;
54667 }
54668
54669
54670 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54671 PyObject *resultobj = 0;
54672 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54673 size_t arg2 ;
54674 wxGBSpan *arg3 = 0 ;
54675 bool result;
54676 void *argp1 = 0 ;
54677 int res1 = 0 ;
54678 size_t val2 ;
54679 int ecode2 = 0 ;
54680 wxGBSpan temp3 ;
54681
54682 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54684 if (!SWIG_IsOK(res1)) {
54685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54686 }
54687 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54688 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54689 if (!SWIG_IsOK(ecode2)) {
54690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54691 }
54692 arg2 = static_cast< size_t >(val2);
54693 {
54694 arg3 = &temp3;
54695 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54696 }
54697 {
54698 PyThreadState* __tstate = wxPyBeginAllowThreads();
54699 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54700 wxPyEndAllowThreads(__tstate);
54701 if (PyErr_Occurred()) SWIG_fail;
54702 }
54703 {
54704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54705 }
54706 return resultobj;
54707 fail:
54708 return NULL;
54709 }
54710
54711
54712 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54713 int argc;
54714 PyObject *argv[4];
54715
54716 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54717 --argc;
54718 if (argc == 3) {
54719 int _v = 0;
54720 {
54721 void *vptr = 0;
54722 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54723 _v = SWIG_CheckState(res);
54724 }
54725 if (!_v) goto check_1;
54726 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54727 }
54728 check_1:
54729
54730 if (argc == 3) {
54731 int _v = 0;
54732 {
54733 void *vptr = 0;
54734 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54735 _v = SWIG_CheckState(res);
54736 }
54737 if (!_v) goto check_2;
54738 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54739 }
54740 check_2:
54741
54742 if (argc == 3) {
54743 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54744 }
54745
54746 fail:
54747 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54748 return NULL;
54749 }
54750
54751
54752 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54753 PyObject *resultobj = 0;
54754 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54755 wxWindow *arg2 = (wxWindow *) 0 ;
54756 wxGBSizerItem *result = 0 ;
54757 void *argp1 = 0 ;
54758 int res1 = 0 ;
54759 void *argp2 = 0 ;
54760 int res2 = 0 ;
54761
54762 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54764 if (!SWIG_IsOK(res1)) {
54765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54766 }
54767 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54768 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54769 if (!SWIG_IsOK(res2)) {
54770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54771 }
54772 arg2 = reinterpret_cast< wxWindow * >(argp2);
54773 {
54774 PyThreadState* __tstate = wxPyBeginAllowThreads();
54775 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54776 wxPyEndAllowThreads(__tstate);
54777 if (PyErr_Occurred()) SWIG_fail;
54778 }
54779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54780 return resultobj;
54781 fail:
54782 return NULL;
54783 }
54784
54785
54786 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54787 PyObject *resultobj = 0;
54788 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54789 wxSizer *arg2 = (wxSizer *) 0 ;
54790 wxGBSizerItem *result = 0 ;
54791 void *argp1 = 0 ;
54792 int res1 = 0 ;
54793 void *argp2 = 0 ;
54794 int res2 = 0 ;
54795
54796 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54798 if (!SWIG_IsOK(res1)) {
54799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54800 }
54801 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54802 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54803 if (!SWIG_IsOK(res2)) {
54804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54805 }
54806 arg2 = reinterpret_cast< wxSizer * >(argp2);
54807 {
54808 PyThreadState* __tstate = wxPyBeginAllowThreads();
54809 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54810 wxPyEndAllowThreads(__tstate);
54811 if (PyErr_Occurred()) SWIG_fail;
54812 }
54813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54814 return resultobj;
54815 fail:
54816 return NULL;
54817 }
54818
54819
54820 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54821 int argc;
54822 PyObject *argv[3];
54823
54824 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54825 --argc;
54826 if (argc == 2) {
54827 int _v = 0;
54828 {
54829 void *vptr = 0;
54830 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54831 _v = SWIG_CheckState(res);
54832 }
54833 if (!_v) goto check_1;
54834 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54835 }
54836 check_1:
54837
54838 if (argc == 2) {
54839 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54840 }
54841
54842 fail:
54843 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54844 return NULL;
54845 }
54846
54847
54848 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54849 PyObject *resultobj = 0;
54850 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54851 wxGBPosition *arg2 = 0 ;
54852 wxGBSizerItem *result = 0 ;
54853 void *argp1 = 0 ;
54854 int res1 = 0 ;
54855 wxGBPosition temp2 ;
54856 PyObject * obj0 = 0 ;
54857 PyObject * obj1 = 0 ;
54858 char * kwnames[] = {
54859 (char *) "self",(char *) "pos", NULL
54860 };
54861
54862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54864 if (!SWIG_IsOK(res1)) {
54865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54866 }
54867 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54868 {
54869 arg2 = &temp2;
54870 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54871 }
54872 {
54873 PyThreadState* __tstate = wxPyBeginAllowThreads();
54874 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54875 wxPyEndAllowThreads(__tstate);
54876 if (PyErr_Occurred()) SWIG_fail;
54877 }
54878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54879 return resultobj;
54880 fail:
54881 return NULL;
54882 }
54883
54884
54885 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54886 PyObject *resultobj = 0;
54887 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54888 wxPoint *arg2 = 0 ;
54889 wxGBSizerItem *result = 0 ;
54890 void *argp1 = 0 ;
54891 int res1 = 0 ;
54892 wxPoint temp2 ;
54893 PyObject * obj0 = 0 ;
54894 PyObject * obj1 = 0 ;
54895 char * kwnames[] = {
54896 (char *) "self",(char *) "pt", NULL
54897 };
54898
54899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54901 if (!SWIG_IsOK(res1)) {
54902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54903 }
54904 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54905 {
54906 arg2 = &temp2;
54907 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54908 }
54909 {
54910 PyThreadState* __tstate = wxPyBeginAllowThreads();
54911 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54912 wxPyEndAllowThreads(__tstate);
54913 if (PyErr_Occurred()) SWIG_fail;
54914 }
54915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54916 return resultobj;
54917 fail:
54918 return NULL;
54919 }
54920
54921
54922 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54923 PyObject *resultobj = 0;
54924 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54925 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54926 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54927 bool result;
54928 void *argp1 = 0 ;
54929 int res1 = 0 ;
54930 void *argp2 = 0 ;
54931 int res2 = 0 ;
54932 void *argp3 = 0 ;
54933 int res3 = 0 ;
54934 PyObject * obj0 = 0 ;
54935 PyObject * obj1 = 0 ;
54936 PyObject * obj2 = 0 ;
54937 char * kwnames[] = {
54938 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54939 };
54940
54941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54943 if (!SWIG_IsOK(res1)) {
54944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54945 }
54946 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54948 if (!SWIG_IsOK(res2)) {
54949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54950 }
54951 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54952 if (obj2) {
54953 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54954 if (!SWIG_IsOK(res3)) {
54955 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54956 }
54957 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54958 }
54959 {
54960 PyThreadState* __tstate = wxPyBeginAllowThreads();
54961 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54962 wxPyEndAllowThreads(__tstate);
54963 if (PyErr_Occurred()) SWIG_fail;
54964 }
54965 {
54966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54967 }
54968 return resultobj;
54969 fail:
54970 return NULL;
54971 }
54972
54973
54974 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54975 PyObject *resultobj = 0;
54976 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54977 wxGBPosition *arg2 = 0 ;
54978 wxGBSpan *arg3 = 0 ;
54979 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54980 bool result;
54981 void *argp1 = 0 ;
54982 int res1 = 0 ;
54983 wxGBPosition temp2 ;
54984 wxGBSpan temp3 ;
54985 void *argp4 = 0 ;
54986 int res4 = 0 ;
54987 PyObject * obj0 = 0 ;
54988 PyObject * obj1 = 0 ;
54989 PyObject * obj2 = 0 ;
54990 PyObject * obj3 = 0 ;
54991 char * kwnames[] = {
54992 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54993 };
54994
54995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54997 if (!SWIG_IsOK(res1)) {
54998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54999 }
55000 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55001 {
55002 arg2 = &temp2;
55003 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55004 }
55005 {
55006 arg3 = &temp3;
55007 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55008 }
55009 if (obj3) {
55010 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55011 if (!SWIG_IsOK(res4)) {
55012 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55013 }
55014 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55015 }
55016 {
55017 PyThreadState* __tstate = wxPyBeginAllowThreads();
55018 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55019 wxPyEndAllowThreads(__tstate);
55020 if (PyErr_Occurred()) SWIG_fail;
55021 }
55022 {
55023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55024 }
55025 return resultobj;
55026 fail:
55027 return NULL;
55028 }
55029
55030
55031 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55032 PyObject *obj;
55033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55034 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55035 return SWIG_Py_Void();
55036 }
55037
55038 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55039 return SWIG_Python_InitShadowInstance(args);
55040 }
55041
55042 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55043 PyObject *resultobj = 0;
55044 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55045 wxRelationship arg2 ;
55046 wxWindow *arg3 = (wxWindow *) 0 ;
55047 wxEdge arg4 ;
55048 int arg5 = (int) 0 ;
55049 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55050 void *argp1 = 0 ;
55051 int res1 = 0 ;
55052 int val2 ;
55053 int ecode2 = 0 ;
55054 void *argp3 = 0 ;
55055 int res3 = 0 ;
55056 int val4 ;
55057 int ecode4 = 0 ;
55058 int val5 ;
55059 int ecode5 = 0 ;
55060 int val6 ;
55061 int ecode6 = 0 ;
55062 PyObject * obj0 = 0 ;
55063 PyObject * obj1 = 0 ;
55064 PyObject * obj2 = 0 ;
55065 PyObject * obj3 = 0 ;
55066 PyObject * obj4 = 0 ;
55067 PyObject * obj5 = 0 ;
55068 char * kwnames[] = {
55069 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55070 };
55071
55072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55074 if (!SWIG_IsOK(res1)) {
55075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55076 }
55077 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55078 ecode2 = SWIG_AsVal_int(obj1, &val2);
55079 if (!SWIG_IsOK(ecode2)) {
55080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55081 }
55082 arg2 = static_cast< wxRelationship >(val2);
55083 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55084 if (!SWIG_IsOK(res3)) {
55085 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55086 }
55087 arg3 = reinterpret_cast< wxWindow * >(argp3);
55088 ecode4 = SWIG_AsVal_int(obj3, &val4);
55089 if (!SWIG_IsOK(ecode4)) {
55090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55091 }
55092 arg4 = static_cast< wxEdge >(val4);
55093 if (obj4) {
55094 ecode5 = SWIG_AsVal_int(obj4, &val5);
55095 if (!SWIG_IsOK(ecode5)) {
55096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55097 }
55098 arg5 = static_cast< int >(val5);
55099 }
55100 if (obj5) {
55101 ecode6 = SWIG_AsVal_int(obj5, &val6);
55102 if (!SWIG_IsOK(ecode6)) {
55103 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55104 }
55105 arg6 = static_cast< int >(val6);
55106 }
55107 {
55108 PyThreadState* __tstate = wxPyBeginAllowThreads();
55109 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55110 wxPyEndAllowThreads(__tstate);
55111 if (PyErr_Occurred()) SWIG_fail;
55112 }
55113 resultobj = SWIG_Py_Void();
55114 return resultobj;
55115 fail:
55116 return NULL;
55117 }
55118
55119
55120 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55121 PyObject *resultobj = 0;
55122 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55123 wxWindow *arg2 = (wxWindow *) 0 ;
55124 int arg3 = (int) 0 ;
55125 void *argp1 = 0 ;
55126 int res1 = 0 ;
55127 void *argp2 = 0 ;
55128 int res2 = 0 ;
55129 int val3 ;
55130 int ecode3 = 0 ;
55131 PyObject * obj0 = 0 ;
55132 PyObject * obj1 = 0 ;
55133 PyObject * obj2 = 0 ;
55134 char * kwnames[] = {
55135 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55136 };
55137
55138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55140 if (!SWIG_IsOK(res1)) {
55141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55142 }
55143 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55145 if (!SWIG_IsOK(res2)) {
55146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55147 }
55148 arg2 = reinterpret_cast< wxWindow * >(argp2);
55149 if (obj2) {
55150 ecode3 = SWIG_AsVal_int(obj2, &val3);
55151 if (!SWIG_IsOK(ecode3)) {
55152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55153 }
55154 arg3 = static_cast< int >(val3);
55155 }
55156 {
55157 PyThreadState* __tstate = wxPyBeginAllowThreads();
55158 (arg1)->LeftOf(arg2,arg3);
55159 wxPyEndAllowThreads(__tstate);
55160 if (PyErr_Occurred()) SWIG_fail;
55161 }
55162 resultobj = SWIG_Py_Void();
55163 return resultobj;
55164 fail:
55165 return NULL;
55166 }
55167
55168
55169 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55170 PyObject *resultobj = 0;
55171 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55172 wxWindow *arg2 = (wxWindow *) 0 ;
55173 int arg3 = (int) 0 ;
55174 void *argp1 = 0 ;
55175 int res1 = 0 ;
55176 void *argp2 = 0 ;
55177 int res2 = 0 ;
55178 int val3 ;
55179 int ecode3 = 0 ;
55180 PyObject * obj0 = 0 ;
55181 PyObject * obj1 = 0 ;
55182 PyObject * obj2 = 0 ;
55183 char * kwnames[] = {
55184 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55185 };
55186
55187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55189 if (!SWIG_IsOK(res1)) {
55190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55191 }
55192 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55194 if (!SWIG_IsOK(res2)) {
55195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55196 }
55197 arg2 = reinterpret_cast< wxWindow * >(argp2);
55198 if (obj2) {
55199 ecode3 = SWIG_AsVal_int(obj2, &val3);
55200 if (!SWIG_IsOK(ecode3)) {
55201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55202 }
55203 arg3 = static_cast< int >(val3);
55204 }
55205 {
55206 PyThreadState* __tstate = wxPyBeginAllowThreads();
55207 (arg1)->RightOf(arg2,arg3);
55208 wxPyEndAllowThreads(__tstate);
55209 if (PyErr_Occurred()) SWIG_fail;
55210 }
55211 resultobj = SWIG_Py_Void();
55212 return resultobj;
55213 fail:
55214 return NULL;
55215 }
55216
55217
55218 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55219 PyObject *resultobj = 0;
55220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55221 wxWindow *arg2 = (wxWindow *) 0 ;
55222 int arg3 = (int) 0 ;
55223 void *argp1 = 0 ;
55224 int res1 = 0 ;
55225 void *argp2 = 0 ;
55226 int res2 = 0 ;
55227 int val3 ;
55228 int ecode3 = 0 ;
55229 PyObject * obj0 = 0 ;
55230 PyObject * obj1 = 0 ;
55231 PyObject * obj2 = 0 ;
55232 char * kwnames[] = {
55233 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55234 };
55235
55236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55238 if (!SWIG_IsOK(res1)) {
55239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55240 }
55241 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55243 if (!SWIG_IsOK(res2)) {
55244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55245 }
55246 arg2 = reinterpret_cast< wxWindow * >(argp2);
55247 if (obj2) {
55248 ecode3 = SWIG_AsVal_int(obj2, &val3);
55249 if (!SWIG_IsOK(ecode3)) {
55250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55251 }
55252 arg3 = static_cast< int >(val3);
55253 }
55254 {
55255 PyThreadState* __tstate = wxPyBeginAllowThreads();
55256 (arg1)->Above(arg2,arg3);
55257 wxPyEndAllowThreads(__tstate);
55258 if (PyErr_Occurred()) SWIG_fail;
55259 }
55260 resultobj = SWIG_Py_Void();
55261 return resultobj;
55262 fail:
55263 return NULL;
55264 }
55265
55266
55267 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55268 PyObject *resultobj = 0;
55269 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55270 wxWindow *arg2 = (wxWindow *) 0 ;
55271 int arg3 = (int) 0 ;
55272 void *argp1 = 0 ;
55273 int res1 = 0 ;
55274 void *argp2 = 0 ;
55275 int res2 = 0 ;
55276 int val3 ;
55277 int ecode3 = 0 ;
55278 PyObject * obj0 = 0 ;
55279 PyObject * obj1 = 0 ;
55280 PyObject * obj2 = 0 ;
55281 char * kwnames[] = {
55282 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55283 };
55284
55285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55287 if (!SWIG_IsOK(res1)) {
55288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55289 }
55290 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55292 if (!SWIG_IsOK(res2)) {
55293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55294 }
55295 arg2 = reinterpret_cast< wxWindow * >(argp2);
55296 if (obj2) {
55297 ecode3 = SWIG_AsVal_int(obj2, &val3);
55298 if (!SWIG_IsOK(ecode3)) {
55299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55300 }
55301 arg3 = static_cast< int >(val3);
55302 }
55303 {
55304 PyThreadState* __tstate = wxPyBeginAllowThreads();
55305 (arg1)->Below(arg2,arg3);
55306 wxPyEndAllowThreads(__tstate);
55307 if (PyErr_Occurred()) SWIG_fail;
55308 }
55309 resultobj = SWIG_Py_Void();
55310 return resultobj;
55311 fail:
55312 return NULL;
55313 }
55314
55315
55316 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55317 PyObject *resultobj = 0;
55318 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55319 wxWindow *arg2 = (wxWindow *) 0 ;
55320 wxEdge arg3 ;
55321 int arg4 = (int) 0 ;
55322 void *argp1 = 0 ;
55323 int res1 = 0 ;
55324 void *argp2 = 0 ;
55325 int res2 = 0 ;
55326 int val3 ;
55327 int ecode3 = 0 ;
55328 int val4 ;
55329 int ecode4 = 0 ;
55330 PyObject * obj0 = 0 ;
55331 PyObject * obj1 = 0 ;
55332 PyObject * obj2 = 0 ;
55333 PyObject * obj3 = 0 ;
55334 char * kwnames[] = {
55335 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55336 };
55337
55338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55340 if (!SWIG_IsOK(res1)) {
55341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55342 }
55343 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55345 if (!SWIG_IsOK(res2)) {
55346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55347 }
55348 arg2 = reinterpret_cast< wxWindow * >(argp2);
55349 ecode3 = SWIG_AsVal_int(obj2, &val3);
55350 if (!SWIG_IsOK(ecode3)) {
55351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55352 }
55353 arg3 = static_cast< wxEdge >(val3);
55354 if (obj3) {
55355 ecode4 = SWIG_AsVal_int(obj3, &val4);
55356 if (!SWIG_IsOK(ecode4)) {
55357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55358 }
55359 arg4 = static_cast< int >(val4);
55360 }
55361 {
55362 PyThreadState* __tstate = wxPyBeginAllowThreads();
55363 (arg1)->SameAs(arg2,arg3,arg4);
55364 wxPyEndAllowThreads(__tstate);
55365 if (PyErr_Occurred()) SWIG_fail;
55366 }
55367 resultobj = SWIG_Py_Void();
55368 return resultobj;
55369 fail:
55370 return NULL;
55371 }
55372
55373
55374 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55375 PyObject *resultobj = 0;
55376 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55377 wxWindow *arg2 = (wxWindow *) 0 ;
55378 wxEdge arg3 ;
55379 int arg4 ;
55380 void *argp1 = 0 ;
55381 int res1 = 0 ;
55382 void *argp2 = 0 ;
55383 int res2 = 0 ;
55384 int val3 ;
55385 int ecode3 = 0 ;
55386 int val4 ;
55387 int ecode4 = 0 ;
55388 PyObject * obj0 = 0 ;
55389 PyObject * obj1 = 0 ;
55390 PyObject * obj2 = 0 ;
55391 PyObject * obj3 = 0 ;
55392 char * kwnames[] = {
55393 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55394 };
55395
55396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55398 if (!SWIG_IsOK(res1)) {
55399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55400 }
55401 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55403 if (!SWIG_IsOK(res2)) {
55404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55405 }
55406 arg2 = reinterpret_cast< wxWindow * >(argp2);
55407 ecode3 = SWIG_AsVal_int(obj2, &val3);
55408 if (!SWIG_IsOK(ecode3)) {
55409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55410 }
55411 arg3 = static_cast< wxEdge >(val3);
55412 ecode4 = SWIG_AsVal_int(obj3, &val4);
55413 if (!SWIG_IsOK(ecode4)) {
55414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55415 }
55416 arg4 = static_cast< int >(val4);
55417 {
55418 PyThreadState* __tstate = wxPyBeginAllowThreads();
55419 (arg1)->PercentOf(arg2,arg3,arg4);
55420 wxPyEndAllowThreads(__tstate);
55421 if (PyErr_Occurred()) SWIG_fail;
55422 }
55423 resultobj = SWIG_Py_Void();
55424 return resultobj;
55425 fail:
55426 return NULL;
55427 }
55428
55429
55430 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55431 PyObject *resultobj = 0;
55432 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55433 int arg2 ;
55434 void *argp1 = 0 ;
55435 int res1 = 0 ;
55436 int val2 ;
55437 int ecode2 = 0 ;
55438 PyObject * obj0 = 0 ;
55439 PyObject * obj1 = 0 ;
55440 char * kwnames[] = {
55441 (char *) "self",(char *) "val", NULL
55442 };
55443
55444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55446 if (!SWIG_IsOK(res1)) {
55447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55448 }
55449 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55450 ecode2 = SWIG_AsVal_int(obj1, &val2);
55451 if (!SWIG_IsOK(ecode2)) {
55452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55453 }
55454 arg2 = static_cast< int >(val2);
55455 {
55456 PyThreadState* __tstate = wxPyBeginAllowThreads();
55457 (arg1)->Absolute(arg2);
55458 wxPyEndAllowThreads(__tstate);
55459 if (PyErr_Occurred()) SWIG_fail;
55460 }
55461 resultobj = SWIG_Py_Void();
55462 return resultobj;
55463 fail:
55464 return NULL;
55465 }
55466
55467
55468 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55469 PyObject *resultobj = 0;
55470 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55471 void *argp1 = 0 ;
55472 int res1 = 0 ;
55473 PyObject *swig_obj[1] ;
55474
55475 if (!args) SWIG_fail;
55476 swig_obj[0] = args;
55477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55478 if (!SWIG_IsOK(res1)) {
55479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55480 }
55481 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55482 {
55483 PyThreadState* __tstate = wxPyBeginAllowThreads();
55484 (arg1)->Unconstrained();
55485 wxPyEndAllowThreads(__tstate);
55486 if (PyErr_Occurred()) SWIG_fail;
55487 }
55488 resultobj = SWIG_Py_Void();
55489 return resultobj;
55490 fail:
55491 return NULL;
55492 }
55493
55494
55495 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55496 PyObject *resultobj = 0;
55497 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55498 void *argp1 = 0 ;
55499 int res1 = 0 ;
55500 PyObject *swig_obj[1] ;
55501
55502 if (!args) SWIG_fail;
55503 swig_obj[0] = args;
55504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55505 if (!SWIG_IsOK(res1)) {
55506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55507 }
55508 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55509 {
55510 PyThreadState* __tstate = wxPyBeginAllowThreads();
55511 (arg1)->AsIs();
55512 wxPyEndAllowThreads(__tstate);
55513 if (PyErr_Occurred()) SWIG_fail;
55514 }
55515 resultobj = SWIG_Py_Void();
55516 return resultobj;
55517 fail:
55518 return NULL;
55519 }
55520
55521
55522 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55523 PyObject *resultobj = 0;
55524 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55525 wxWindow *result = 0 ;
55526 void *argp1 = 0 ;
55527 int res1 = 0 ;
55528 PyObject *swig_obj[1] ;
55529
55530 if (!args) SWIG_fail;
55531 swig_obj[0] = args;
55532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55533 if (!SWIG_IsOK(res1)) {
55534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55535 }
55536 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55537 {
55538 PyThreadState* __tstate = wxPyBeginAllowThreads();
55539 result = (wxWindow *)(arg1)->GetOtherWindow();
55540 wxPyEndAllowThreads(__tstate);
55541 if (PyErr_Occurred()) SWIG_fail;
55542 }
55543 {
55544 resultobj = wxPyMake_wxObject(result, 0);
55545 }
55546 return resultobj;
55547 fail:
55548 return NULL;
55549 }
55550
55551
55552 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55553 PyObject *resultobj = 0;
55554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55555 wxEdge result;
55556 void *argp1 = 0 ;
55557 int res1 = 0 ;
55558 PyObject *swig_obj[1] ;
55559
55560 if (!args) SWIG_fail;
55561 swig_obj[0] = args;
55562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55563 if (!SWIG_IsOK(res1)) {
55564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55565 }
55566 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55567 {
55568 PyThreadState* __tstate = wxPyBeginAllowThreads();
55569 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55570 wxPyEndAllowThreads(__tstate);
55571 if (PyErr_Occurred()) SWIG_fail;
55572 }
55573 resultobj = SWIG_From_int(static_cast< int >(result));
55574 return resultobj;
55575 fail:
55576 return NULL;
55577 }
55578
55579
55580 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55581 PyObject *resultobj = 0;
55582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55583 wxEdge arg2 ;
55584 void *argp1 = 0 ;
55585 int res1 = 0 ;
55586 int val2 ;
55587 int ecode2 = 0 ;
55588 PyObject * obj0 = 0 ;
55589 PyObject * obj1 = 0 ;
55590 char * kwnames[] = {
55591 (char *) "self",(char *) "which", NULL
55592 };
55593
55594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55596 if (!SWIG_IsOK(res1)) {
55597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55598 }
55599 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55600 ecode2 = SWIG_AsVal_int(obj1, &val2);
55601 if (!SWIG_IsOK(ecode2)) {
55602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55603 }
55604 arg2 = static_cast< wxEdge >(val2);
55605 {
55606 PyThreadState* __tstate = wxPyBeginAllowThreads();
55607 (arg1)->SetEdge(arg2);
55608 wxPyEndAllowThreads(__tstate);
55609 if (PyErr_Occurred()) SWIG_fail;
55610 }
55611 resultobj = SWIG_Py_Void();
55612 return resultobj;
55613 fail:
55614 return NULL;
55615 }
55616
55617
55618 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55619 PyObject *resultobj = 0;
55620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55621 int arg2 ;
55622 void *argp1 = 0 ;
55623 int res1 = 0 ;
55624 int val2 ;
55625 int ecode2 = 0 ;
55626 PyObject * obj0 = 0 ;
55627 PyObject * obj1 = 0 ;
55628 char * kwnames[] = {
55629 (char *) "self",(char *) "v", NULL
55630 };
55631
55632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55634 if (!SWIG_IsOK(res1)) {
55635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55636 }
55637 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55638 ecode2 = SWIG_AsVal_int(obj1, &val2);
55639 if (!SWIG_IsOK(ecode2)) {
55640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55641 }
55642 arg2 = static_cast< int >(val2);
55643 {
55644 PyThreadState* __tstate = wxPyBeginAllowThreads();
55645 (arg1)->SetValue(arg2);
55646 wxPyEndAllowThreads(__tstate);
55647 if (PyErr_Occurred()) SWIG_fail;
55648 }
55649 resultobj = SWIG_Py_Void();
55650 return resultobj;
55651 fail:
55652 return NULL;
55653 }
55654
55655
55656 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55657 PyObject *resultobj = 0;
55658 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55659 int result;
55660 void *argp1 = 0 ;
55661 int res1 = 0 ;
55662 PyObject *swig_obj[1] ;
55663
55664 if (!args) SWIG_fail;
55665 swig_obj[0] = args;
55666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55667 if (!SWIG_IsOK(res1)) {
55668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55669 }
55670 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55671 {
55672 PyThreadState* __tstate = wxPyBeginAllowThreads();
55673 result = (int)(arg1)->GetMargin();
55674 wxPyEndAllowThreads(__tstate);
55675 if (PyErr_Occurred()) SWIG_fail;
55676 }
55677 resultobj = SWIG_From_int(static_cast< int >(result));
55678 return resultobj;
55679 fail:
55680 return NULL;
55681 }
55682
55683
55684 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55685 PyObject *resultobj = 0;
55686 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55687 int arg2 ;
55688 void *argp1 = 0 ;
55689 int res1 = 0 ;
55690 int val2 ;
55691 int ecode2 = 0 ;
55692 PyObject * obj0 = 0 ;
55693 PyObject * obj1 = 0 ;
55694 char * kwnames[] = {
55695 (char *) "self",(char *) "m", NULL
55696 };
55697
55698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55700 if (!SWIG_IsOK(res1)) {
55701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55702 }
55703 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55704 ecode2 = SWIG_AsVal_int(obj1, &val2);
55705 if (!SWIG_IsOK(ecode2)) {
55706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55707 }
55708 arg2 = static_cast< int >(val2);
55709 {
55710 PyThreadState* __tstate = wxPyBeginAllowThreads();
55711 (arg1)->SetMargin(arg2);
55712 wxPyEndAllowThreads(__tstate);
55713 if (PyErr_Occurred()) SWIG_fail;
55714 }
55715 resultobj = SWIG_Py_Void();
55716 return resultobj;
55717 fail:
55718 return NULL;
55719 }
55720
55721
55722 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55723 PyObject *resultobj = 0;
55724 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55725 int result;
55726 void *argp1 = 0 ;
55727 int res1 = 0 ;
55728 PyObject *swig_obj[1] ;
55729
55730 if (!args) SWIG_fail;
55731 swig_obj[0] = args;
55732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55733 if (!SWIG_IsOK(res1)) {
55734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55735 }
55736 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55737 {
55738 PyThreadState* __tstate = wxPyBeginAllowThreads();
55739 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55740 wxPyEndAllowThreads(__tstate);
55741 if (PyErr_Occurred()) SWIG_fail;
55742 }
55743 resultobj = SWIG_From_int(static_cast< int >(result));
55744 return resultobj;
55745 fail:
55746 return NULL;
55747 }
55748
55749
55750 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55751 PyObject *resultobj = 0;
55752 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55753 int result;
55754 void *argp1 = 0 ;
55755 int res1 = 0 ;
55756 PyObject *swig_obj[1] ;
55757
55758 if (!args) SWIG_fail;
55759 swig_obj[0] = args;
55760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55761 if (!SWIG_IsOK(res1)) {
55762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55763 }
55764 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55765 {
55766 PyThreadState* __tstate = wxPyBeginAllowThreads();
55767 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55768 wxPyEndAllowThreads(__tstate);
55769 if (PyErr_Occurred()) SWIG_fail;
55770 }
55771 resultobj = SWIG_From_int(static_cast< int >(result));
55772 return resultobj;
55773 fail:
55774 return NULL;
55775 }
55776
55777
55778 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55779 PyObject *resultobj = 0;
55780 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55781 int result;
55782 void *argp1 = 0 ;
55783 int res1 = 0 ;
55784 PyObject *swig_obj[1] ;
55785
55786 if (!args) SWIG_fail;
55787 swig_obj[0] = args;
55788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55789 if (!SWIG_IsOK(res1)) {
55790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55791 }
55792 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55793 {
55794 PyThreadState* __tstate = wxPyBeginAllowThreads();
55795 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55796 wxPyEndAllowThreads(__tstate);
55797 if (PyErr_Occurred()) SWIG_fail;
55798 }
55799 resultobj = SWIG_From_int(static_cast< int >(result));
55800 return resultobj;
55801 fail:
55802 return NULL;
55803 }
55804
55805
55806 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55807 PyObject *resultobj = 0;
55808 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55809 bool result;
55810 void *argp1 = 0 ;
55811 int res1 = 0 ;
55812 PyObject *swig_obj[1] ;
55813
55814 if (!args) SWIG_fail;
55815 swig_obj[0] = args;
55816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55817 if (!SWIG_IsOK(res1)) {
55818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55819 }
55820 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55821 {
55822 PyThreadState* __tstate = wxPyBeginAllowThreads();
55823 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55824 wxPyEndAllowThreads(__tstate);
55825 if (PyErr_Occurred()) SWIG_fail;
55826 }
55827 {
55828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55829 }
55830 return resultobj;
55831 fail:
55832 return NULL;
55833 }
55834
55835
55836 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55837 PyObject *resultobj = 0;
55838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55839 bool arg2 ;
55840 void *argp1 = 0 ;
55841 int res1 = 0 ;
55842 bool val2 ;
55843 int ecode2 = 0 ;
55844 PyObject * obj0 = 0 ;
55845 PyObject * obj1 = 0 ;
55846 char * kwnames[] = {
55847 (char *) "self",(char *) "d", NULL
55848 };
55849
55850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55852 if (!SWIG_IsOK(res1)) {
55853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55854 }
55855 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55856 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55857 if (!SWIG_IsOK(ecode2)) {
55858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55859 }
55860 arg2 = static_cast< bool >(val2);
55861 {
55862 PyThreadState* __tstate = wxPyBeginAllowThreads();
55863 (arg1)->SetDone(arg2);
55864 wxPyEndAllowThreads(__tstate);
55865 if (PyErr_Occurred()) SWIG_fail;
55866 }
55867 resultobj = SWIG_Py_Void();
55868 return resultobj;
55869 fail:
55870 return NULL;
55871 }
55872
55873
55874 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55875 PyObject *resultobj = 0;
55876 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55877 wxRelationship result;
55878 void *argp1 = 0 ;
55879 int res1 = 0 ;
55880 PyObject *swig_obj[1] ;
55881
55882 if (!args) SWIG_fail;
55883 swig_obj[0] = args;
55884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55885 if (!SWIG_IsOK(res1)) {
55886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55887 }
55888 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55889 {
55890 PyThreadState* __tstate = wxPyBeginAllowThreads();
55891 result = (wxRelationship)(arg1)->GetRelationship();
55892 wxPyEndAllowThreads(__tstate);
55893 if (PyErr_Occurred()) SWIG_fail;
55894 }
55895 resultobj = SWIG_From_int(static_cast< int >(result));
55896 return resultobj;
55897 fail:
55898 return NULL;
55899 }
55900
55901
55902 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55903 PyObject *resultobj = 0;
55904 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55905 wxRelationship arg2 ;
55906 void *argp1 = 0 ;
55907 int res1 = 0 ;
55908 int val2 ;
55909 int ecode2 = 0 ;
55910 PyObject * obj0 = 0 ;
55911 PyObject * obj1 = 0 ;
55912 char * kwnames[] = {
55913 (char *) "self",(char *) "r", NULL
55914 };
55915
55916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55918 if (!SWIG_IsOK(res1)) {
55919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55920 }
55921 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55922 ecode2 = SWIG_AsVal_int(obj1, &val2);
55923 if (!SWIG_IsOK(ecode2)) {
55924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55925 }
55926 arg2 = static_cast< wxRelationship >(val2);
55927 {
55928 PyThreadState* __tstate = wxPyBeginAllowThreads();
55929 (arg1)->SetRelationship(arg2);
55930 wxPyEndAllowThreads(__tstate);
55931 if (PyErr_Occurred()) SWIG_fail;
55932 }
55933 resultobj = SWIG_Py_Void();
55934 return resultobj;
55935 fail:
55936 return NULL;
55937 }
55938
55939
55940 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55941 PyObject *resultobj = 0;
55942 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55943 wxWindow *arg2 = (wxWindow *) 0 ;
55944 bool result;
55945 void *argp1 = 0 ;
55946 int res1 = 0 ;
55947 void *argp2 = 0 ;
55948 int res2 = 0 ;
55949 PyObject * obj0 = 0 ;
55950 PyObject * obj1 = 0 ;
55951 char * kwnames[] = {
55952 (char *) "self",(char *) "otherW", NULL
55953 };
55954
55955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55957 if (!SWIG_IsOK(res1)) {
55958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55959 }
55960 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55962 if (!SWIG_IsOK(res2)) {
55963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55964 }
55965 arg2 = reinterpret_cast< wxWindow * >(argp2);
55966 {
55967 PyThreadState* __tstate = wxPyBeginAllowThreads();
55968 result = (bool)(arg1)->ResetIfWin(arg2);
55969 wxPyEndAllowThreads(__tstate);
55970 if (PyErr_Occurred()) SWIG_fail;
55971 }
55972 {
55973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55974 }
55975 return resultobj;
55976 fail:
55977 return NULL;
55978 }
55979
55980
55981 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55982 PyObject *resultobj = 0;
55983 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55984 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55985 wxWindow *arg3 = (wxWindow *) 0 ;
55986 bool result;
55987 void *argp1 = 0 ;
55988 int res1 = 0 ;
55989 void *argp2 = 0 ;
55990 int res2 = 0 ;
55991 void *argp3 = 0 ;
55992 int res3 = 0 ;
55993 PyObject * obj0 = 0 ;
55994 PyObject * obj1 = 0 ;
55995 PyObject * obj2 = 0 ;
55996 char * kwnames[] = {
55997 (char *) "self",(char *) "constraints",(char *) "win", NULL
55998 };
55999
56000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56002 if (!SWIG_IsOK(res1)) {
56003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56004 }
56005 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56006 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56007 if (!SWIG_IsOK(res2)) {
56008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56009 }
56010 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56011 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56012 if (!SWIG_IsOK(res3)) {
56013 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56014 }
56015 arg3 = reinterpret_cast< wxWindow * >(argp3);
56016 {
56017 PyThreadState* __tstate = wxPyBeginAllowThreads();
56018 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56019 wxPyEndAllowThreads(__tstate);
56020 if (PyErr_Occurred()) SWIG_fail;
56021 }
56022 {
56023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56024 }
56025 return resultobj;
56026 fail:
56027 return NULL;
56028 }
56029
56030
56031 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56032 PyObject *resultobj = 0;
56033 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56034 wxEdge arg2 ;
56035 wxWindow *arg3 = (wxWindow *) 0 ;
56036 wxWindow *arg4 = (wxWindow *) 0 ;
56037 int result;
56038 void *argp1 = 0 ;
56039 int res1 = 0 ;
56040 int val2 ;
56041 int ecode2 = 0 ;
56042 void *argp3 = 0 ;
56043 int res3 = 0 ;
56044 void *argp4 = 0 ;
56045 int res4 = 0 ;
56046 PyObject * obj0 = 0 ;
56047 PyObject * obj1 = 0 ;
56048 PyObject * obj2 = 0 ;
56049 PyObject * obj3 = 0 ;
56050 char * kwnames[] = {
56051 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56052 };
56053
56054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56056 if (!SWIG_IsOK(res1)) {
56057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56058 }
56059 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56060 ecode2 = SWIG_AsVal_int(obj1, &val2);
56061 if (!SWIG_IsOK(ecode2)) {
56062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56063 }
56064 arg2 = static_cast< wxEdge >(val2);
56065 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56066 if (!SWIG_IsOK(res3)) {
56067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56068 }
56069 arg3 = reinterpret_cast< wxWindow * >(argp3);
56070 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56071 if (!SWIG_IsOK(res4)) {
56072 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56073 }
56074 arg4 = reinterpret_cast< wxWindow * >(argp4);
56075 {
56076 PyThreadState* __tstate = wxPyBeginAllowThreads();
56077 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56078 wxPyEndAllowThreads(__tstate);
56079 if (PyErr_Occurred()) SWIG_fail;
56080 }
56081 resultobj = SWIG_From_int(static_cast< int >(result));
56082 return resultobj;
56083 fail:
56084 return NULL;
56085 }
56086
56087
56088 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56089 PyObject *obj;
56090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56091 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56092 return SWIG_Py_Void();
56093 }
56094
56095 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56096 PyObject *resultobj = 0;
56097 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56098 wxIndividualLayoutConstraint *result = 0 ;
56099 void *argp1 = 0 ;
56100 int res1 = 0 ;
56101 PyObject *swig_obj[1] ;
56102
56103 if (!args) SWIG_fail;
56104 swig_obj[0] = args;
56105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56106 if (!SWIG_IsOK(res1)) {
56107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56108 }
56109 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56110 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56112 return resultobj;
56113 fail:
56114 return NULL;
56115 }
56116
56117
56118 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56119 PyObject *resultobj = 0;
56120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56121 wxIndividualLayoutConstraint *result = 0 ;
56122 void *argp1 = 0 ;
56123 int res1 = 0 ;
56124 PyObject *swig_obj[1] ;
56125
56126 if (!args) SWIG_fail;
56127 swig_obj[0] = args;
56128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56129 if (!SWIG_IsOK(res1)) {
56130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56131 }
56132 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56133 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56135 return resultobj;
56136 fail:
56137 return NULL;
56138 }
56139
56140
56141 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56142 PyObject *resultobj = 0;
56143 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56144 wxIndividualLayoutConstraint *result = 0 ;
56145 void *argp1 = 0 ;
56146 int res1 = 0 ;
56147 PyObject *swig_obj[1] ;
56148
56149 if (!args) SWIG_fail;
56150 swig_obj[0] = args;
56151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56152 if (!SWIG_IsOK(res1)) {
56153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56154 }
56155 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56156 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56158 return resultobj;
56159 fail:
56160 return NULL;
56161 }
56162
56163
56164 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56165 PyObject *resultobj = 0;
56166 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56167 wxIndividualLayoutConstraint *result = 0 ;
56168 void *argp1 = 0 ;
56169 int res1 = 0 ;
56170 PyObject *swig_obj[1] ;
56171
56172 if (!args) SWIG_fail;
56173 swig_obj[0] = args;
56174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56175 if (!SWIG_IsOK(res1)) {
56176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56177 }
56178 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56179 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56181 return resultobj;
56182 fail:
56183 return NULL;
56184 }
56185
56186
56187 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56188 PyObject *resultobj = 0;
56189 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56190 wxIndividualLayoutConstraint *result = 0 ;
56191 void *argp1 = 0 ;
56192 int res1 = 0 ;
56193 PyObject *swig_obj[1] ;
56194
56195 if (!args) SWIG_fail;
56196 swig_obj[0] = args;
56197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56198 if (!SWIG_IsOK(res1)) {
56199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56200 }
56201 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56202 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56204 return resultobj;
56205 fail:
56206 return NULL;
56207 }
56208
56209
56210 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56211 PyObject *resultobj = 0;
56212 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56213 wxIndividualLayoutConstraint *result = 0 ;
56214 void *argp1 = 0 ;
56215 int res1 = 0 ;
56216 PyObject *swig_obj[1] ;
56217
56218 if (!args) SWIG_fail;
56219 swig_obj[0] = args;
56220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56221 if (!SWIG_IsOK(res1)) {
56222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56223 }
56224 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56225 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56227 return resultobj;
56228 fail:
56229 return NULL;
56230 }
56231
56232
56233 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56234 PyObject *resultobj = 0;
56235 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56236 wxIndividualLayoutConstraint *result = 0 ;
56237 void *argp1 = 0 ;
56238 int res1 = 0 ;
56239 PyObject *swig_obj[1] ;
56240
56241 if (!args) SWIG_fail;
56242 swig_obj[0] = args;
56243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56244 if (!SWIG_IsOK(res1)) {
56245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56246 }
56247 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56248 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56250 return resultobj;
56251 fail:
56252 return NULL;
56253 }
56254
56255
56256 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56257 PyObject *resultobj = 0;
56258 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56259 wxIndividualLayoutConstraint *result = 0 ;
56260 void *argp1 = 0 ;
56261 int res1 = 0 ;
56262 PyObject *swig_obj[1] ;
56263
56264 if (!args) SWIG_fail;
56265 swig_obj[0] = args;
56266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56267 if (!SWIG_IsOK(res1)) {
56268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56269 }
56270 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56271 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56273 return resultobj;
56274 fail:
56275 return NULL;
56276 }
56277
56278
56279 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56280 PyObject *resultobj = 0;
56281 wxLayoutConstraints *result = 0 ;
56282
56283 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56284 {
56285 PyThreadState* __tstate = wxPyBeginAllowThreads();
56286 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56287 wxPyEndAllowThreads(__tstate);
56288 if (PyErr_Occurred()) SWIG_fail;
56289 }
56290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56291 return resultobj;
56292 fail:
56293 return NULL;
56294 }
56295
56296
56297 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56298 PyObject *resultobj = 0;
56299 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56300 void *argp1 = 0 ;
56301 int res1 = 0 ;
56302 PyObject *swig_obj[1] ;
56303
56304 if (!args) SWIG_fail;
56305 swig_obj[0] = args;
56306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56307 if (!SWIG_IsOK(res1)) {
56308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56309 }
56310 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56311 {
56312 PyThreadState* __tstate = wxPyBeginAllowThreads();
56313 delete arg1;
56314
56315 wxPyEndAllowThreads(__tstate);
56316 if (PyErr_Occurred()) SWIG_fail;
56317 }
56318 resultobj = SWIG_Py_Void();
56319 return resultobj;
56320 fail:
56321 return NULL;
56322 }
56323
56324
56325 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56326 PyObject *resultobj = 0;
56327 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56328 wxWindow *arg2 = (wxWindow *) 0 ;
56329 int *arg3 = (int *) 0 ;
56330 bool result;
56331 void *argp1 = 0 ;
56332 int res1 = 0 ;
56333 void *argp2 = 0 ;
56334 int res2 = 0 ;
56335 int temp3 ;
56336 int res3 = SWIG_TMPOBJ ;
56337 PyObject * obj0 = 0 ;
56338 PyObject * obj1 = 0 ;
56339 char * kwnames[] = {
56340 (char *) "self",(char *) "win", NULL
56341 };
56342
56343 arg3 = &temp3;
56344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56346 if (!SWIG_IsOK(res1)) {
56347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56348 }
56349 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56350 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56351 if (!SWIG_IsOK(res2)) {
56352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56353 }
56354 arg2 = reinterpret_cast< wxWindow * >(argp2);
56355 {
56356 PyThreadState* __tstate = wxPyBeginAllowThreads();
56357 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56358 wxPyEndAllowThreads(__tstate);
56359 if (PyErr_Occurred()) SWIG_fail;
56360 }
56361 {
56362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56363 }
56364 if (SWIG_IsTmpObj(res3)) {
56365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56366 } else {
56367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56369 }
56370 return resultobj;
56371 fail:
56372 return NULL;
56373 }
56374
56375
56376 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56377 PyObject *resultobj = 0;
56378 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56379 bool result;
56380 void *argp1 = 0 ;
56381 int res1 = 0 ;
56382 PyObject *swig_obj[1] ;
56383
56384 if (!args) SWIG_fail;
56385 swig_obj[0] = args;
56386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56387 if (!SWIG_IsOK(res1)) {
56388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56389 }
56390 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56391 {
56392 PyThreadState* __tstate = wxPyBeginAllowThreads();
56393 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56394 wxPyEndAllowThreads(__tstate);
56395 if (PyErr_Occurred()) SWIG_fail;
56396 }
56397 {
56398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56399 }
56400 return resultobj;
56401 fail:
56402 return NULL;
56403 }
56404
56405
56406 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56407 PyObject *obj;
56408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56409 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56410 return SWIG_Py_Void();
56411 }
56412
56413 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56414 return SWIG_Python_InitShadowInstance(args);
56415 }
56416
56417 static PyMethodDef SwigMethods[] = {
56418 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56419 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56420 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56421 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56422 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56423 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56424 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56425 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56426 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56427 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56428 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56429 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56432 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56433 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56434 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56435 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56437 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56439 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56441 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56442 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56443 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56445 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56446 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56447 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56448 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56449 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56450 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56451 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56452 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56453 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56459 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56460 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56461 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56462 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56463 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56464 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56465 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56467 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56475 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56476 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56477 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56478 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56482 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56483 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56485 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56487 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56489 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56491 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56493 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56495 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56496 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56498 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56500 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56502 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56504 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56505 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56506 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56507 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56527 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56528 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56529 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56530 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56531 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56532 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56533 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56534 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56536 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56537 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56538 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56543 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56544 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56545 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56546 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56547 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56554 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56555 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56561 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56562 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56563 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56564 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56566 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56567 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56568 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56570 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56571 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56572 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56573 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56576 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56578 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56579 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56582 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56585 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56588 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56591 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56594 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56596 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56597 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56603 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56605 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56614 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56617 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56618 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56619 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56620 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56621 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56622 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56623 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56624 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56626 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56627 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56628 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56630 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56631 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56632 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56633 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56638 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56639 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56640 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56641 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56642 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56643 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56646 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56647 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56648 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56650 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56651 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56652 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56653 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56654 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56655 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56656 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56657 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56658 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56659 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56660 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56661 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56662 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56663 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56664 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56669 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56675 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56676 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56677 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56678 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56680 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56681 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56683 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56686 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56689 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56690 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56691 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56694 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56695 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56696 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56700 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56701 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56702 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56706 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56711 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56712 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56713 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56714 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56715 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56716 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56717 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56724 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56725 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56727 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56728 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56729 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56735 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56736 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56738 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56739 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56740 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56741 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56742 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56743 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56744 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56745 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56747 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56748 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56749 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56750 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56751 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56752 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56753 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56754 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56756 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56765 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56782 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56783 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56798 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56799 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56800 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56801 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56804 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56806 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56808 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56810 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56812 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56815 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56816 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56817 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56818 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56820 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56837 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56838 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56844 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56845 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56847 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56848 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56849 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56850 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56851 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56852 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56853 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56854 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56855 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56856 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56857 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56858 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56859 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56860 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56861 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56862 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56863 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56864 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56865 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56866 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56867 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56868 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56869 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56870 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56871 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56872 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56873 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56874 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56875 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56876 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56877 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56878 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56879 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56881 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56882 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56883 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56884 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56887 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56891 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56892 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56893 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56894 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56895 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56896 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56898 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56899 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56900 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56901 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56903 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56904 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56905 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56906 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56908 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56910 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56911 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56912 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56913 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56914 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56916 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56917 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56919 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56920 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56921 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56923 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56924 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56925 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56927 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56929 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56930 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56931 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56933 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56934 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56935 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56936 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56937 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56938 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56939 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56940 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56942 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56943 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56944 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56945 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56946 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56947 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56948 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56949 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56951 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56952 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56953 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56955 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56956 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56959 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56960 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56961 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56962 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56963 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56966 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56968 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56969 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56970 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56971 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56972 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56973 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56974 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56975 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56976 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56977 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56978 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56979 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56980 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56981 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56982 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56983 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56984 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56985 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56986 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56987 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56988 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56989 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56990 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56991 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56992 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56993 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56994 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56995 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56996 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56997 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56998 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56999 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57000 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57001 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57002 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57003 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57004 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57005 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57006 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57007 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57008 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57009 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57010 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57011 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57012 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57013 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57014 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57015 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57016 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57017 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57018 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57019 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57020 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57021 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57022 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57023 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57024 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57025 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57026 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57027 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57028 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57029 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57030 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57031 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57032 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57033 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57034 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57035 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57036 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57037 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57038 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57039 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57040 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57041 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57042 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57043 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57044 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57045 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57046 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57047 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57048 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57049 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57050 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57051 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57052 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57053 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57054 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57055 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57056 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57057 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57058 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57059 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57060 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57061 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57062 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57063 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57064 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57065 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57066 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57067 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57068 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57069 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57070 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57071 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57072 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57073 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57074 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57075 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57076 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57077 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57078 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57079 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57080 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57081 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57082 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57084 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57085 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57087 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57088 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57089 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57090 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57091 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57092 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57094 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57095 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57097 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57099 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57101 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57105 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57106 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57107 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57108 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57110 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57111 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57112 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57114 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57115 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57117 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57118 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57119 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57120 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57121 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57124 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57126 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57128 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57129 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57130 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57133 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57134 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57135 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57136 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57137 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57138 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57139 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57143 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57144 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57145 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57146 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57147 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57148 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57149 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57150 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57151 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57152 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57153 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57154 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57155 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57156 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57158 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57160 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57161 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57163 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57165 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57166 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57167 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57168 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57169 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57170 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57171 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57172 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57173 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57174 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57176 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57177 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57178 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57179 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57180 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57181 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57182 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57183 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57184 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57185 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57188 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57189 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57190 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57191 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57192 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57194 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57195 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57196 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57197 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57199 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57201 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57202 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57204 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57205 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57206 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57208 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57209 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57210 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57212 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57214 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57215 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57216 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57217 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57218 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57220 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57222 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57223 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57225 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57226 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57228 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57229 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57230 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57231 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57232 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57233 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57234 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57236 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57237 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57238 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57240 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57241 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57242 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57243 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57244 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57245 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57247 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57249 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57251 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57253 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57254 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57255 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57256 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57257 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57258 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57259 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57260 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57261 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57262 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57263 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57264 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57266 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57268 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57270 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57272 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57273 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57274 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57276 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57277 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57278 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57279 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57280 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57281 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57287 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57288 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57289 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57290 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57291 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57292 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57293 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57294 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57296 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57298 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57299 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57301 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57302 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57303 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57304 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57306 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57307 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57308 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57309 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57311 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57312 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57314 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57315 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57316 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57318 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57319 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57321 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57322 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57323 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57324 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57325 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57327 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57328 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57329 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57330 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57331 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57332 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57333 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57334 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57335 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57336 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57337 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57338 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57339 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57340 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57341 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57342 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57343 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57344 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57346 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57349 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57350 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57351 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57353 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57355 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57357 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57359 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57360 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57363 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57373 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57374 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57378 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57379 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57380 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57381 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57382 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57383 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57384 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57385 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57386 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57387 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57388 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57389 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57390 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57391 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57392 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
57394 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
57395 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57398 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57399 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57404 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57405 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57406 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57408 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57409 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57410 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57411 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57414 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57415 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57416 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57418 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57420 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57421 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57422 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57423 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57425 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57427 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57429 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57432 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57433 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57434 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57435 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57436 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57437 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57441 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57442 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57443 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57444 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57448 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57449 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57451 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57457 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57458 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57459 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57460 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57461 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57463 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57473 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57474 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57475 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57476 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57479 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57480 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57481 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57482 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57483 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57485 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57486 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57487 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57490 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57491 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57497 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57498 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57499 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57500 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57502 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57503 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57505 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57508 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57510 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57511 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57512 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57513 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57521 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57525 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57526 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57528 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57539 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57540 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57541 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57542 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57546 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57549 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57551 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57554 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57556 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57557 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57560 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57562 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57563 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57564 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57565 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57567 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57568 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57573 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57574 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57575 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57577 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57578 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57579 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57581 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57583 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57584 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57585 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57587 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57588 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57591 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57599 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57606 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57614 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57617 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57618 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57631 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57633 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57635 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57636 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57638 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57640 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57641 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57643 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57644 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57645 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57649 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57668 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57669 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57671 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57672 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57674 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57675 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57676 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57678 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57679 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57682 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57683 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57685 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57686 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57688 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57691 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57692 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57694 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57696 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57698 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57699 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57701 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57702 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57705 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57707 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57709 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57711 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57714 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57716 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57717 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57718 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57720 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57721 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57722 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57724 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57726 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57727 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57730 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57731 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57735 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57739 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57740 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57742 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57746 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57748 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57750 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57751 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57752 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57753 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57757 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57758 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57759 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57760 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57762 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57763 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57768 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57769 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57770 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57771 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57772 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57774 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57776 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57778 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57779 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57781 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57783 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57786 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57787 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57788 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57790 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57791 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57792 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57805 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57811 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57812 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57813 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57814 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57815 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57816 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57822 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57823 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57827 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57828 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57830 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57831 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57833 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57835 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57836 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57838 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57839 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57840 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57846 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57847 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57848 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57849 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57850 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57851 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57858 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57860 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57861 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57862 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57863 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57864 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57865 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57867 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57871 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57872 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57873 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57874 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57875 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57876 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57877 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57879 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57880 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57881 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57887 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57888 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57889 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57891 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57892 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57893 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57898 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57899 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57900 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57901 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57902 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57903 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57907 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57908 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57913 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57914 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57916 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57917 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57922 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57924 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57925 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57926 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57927 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57928 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57933 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57934 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57943 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57944 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57945 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57946 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57949 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57951 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57952 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57953 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57954 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57956 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57961 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57962 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57963 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57964 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57965 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57966 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57967 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57968 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57969 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57970 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57971 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57973 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57974 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57975 { NULL, NULL, 0, NULL }
57976 };
57977
57978
57979 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57980
57981 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57982 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57983 }
57984 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57985 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57986 }
57987 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57988 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57989 }
57990 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57991 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57992 }
57993 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57994 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57995 }
57996 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57997 return (void *)((wxSizer *) ((wxGridSizer *) x));
57998 }
57999 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58000 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58001 }
58002 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58003 return (void *)((wxSizer *) ((wxPySizer *) x));
58004 }
58005 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58006 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58007 }
58008 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58009 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58010 }
58011 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58012 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58013 }
58014 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58015 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58016 }
58017 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58018 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58019 }
58020 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58021 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58022 }
58023 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58024 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58025 }
58026 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58027 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58028 }
58029 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58030 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58031 }
58032 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58033 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58034 }
58035 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58037 }
58038 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58039 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58040 }
58041 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58042 return (void *)((wxEvent *) ((wxPyEvent *) x));
58043 }
58044 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58045 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58046 }
58047 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58048 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58049 }
58050 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58051 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58052 }
58053 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58054 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58055 }
58056 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58057 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58058 }
58059 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58060 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58061 }
58062 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58063 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58064 }
58065 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58066 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58067 }
58068 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58069 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58070 }
58071 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58072 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58073 }
58074 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58075 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58076 }
58077 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58078 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58079 }
58080 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58081 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58082 }
58083 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58084 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58085 }
58086 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58087 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58088 }
58089 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58090 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58091 }
58092 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58093 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58094 }
58095 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58096 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58097 }
58098 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58099 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58100 }
58101 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58102 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58103 }
58104 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58105 return (void *)((wxEvent *) ((wxShowEvent *) x));
58106 }
58107 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58108 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58109 }
58110 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58112 }
58113 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58114 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58115 }
58116 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58117 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58118 }
58119 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58120 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58121 }
58122 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58123 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58124 }
58125 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58126 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58127 }
58128 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58129 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58130 }
58131 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58132 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58133 }
58134 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58135 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58136 }
58137 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58138 return (void *)((wxControl *) ((wxControlWithItems *) x));
58139 }
58140 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58141 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58142 }
58143 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58144 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58145 }
58146 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58147 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58148 }
58149 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58150 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58151 }
58152 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58153 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58154 }
58155 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58156 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58157 }
58158 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58159 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58160 }
58161 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58162 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58163 }
58164 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58165 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58166 }
58167 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58168 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58169 }
58170 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58171 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58172 }
58173 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58174 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58175 }
58176 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58177 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58178 }
58179 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58180 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58181 }
58182 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58183 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58184 }
58185 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58186 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58187 }
58188 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58189 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58190 }
58191 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58192 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58193 }
58194 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58195 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58196 }
58197 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58198 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58199 }
58200 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58201 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58202 }
58203 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58204 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58205 }
58206 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58207 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58208 }
58209 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58210 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58211 }
58212 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58213 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58214 }
58215 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58216 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58217 }
58218 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58219 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58220 }
58221 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58222 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58223 }
58224 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58225 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58226 }
58227 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58228 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58229 }
58230 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58231 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58232 }
58233 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58234 return (void *)((wxObject *) ((wxSizerItem *) x));
58235 }
58236 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58237 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58238 }
58239 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58240 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58241 }
58242 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58243 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58244 }
58245 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58246 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58247 }
58248 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58249 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58250 }
58251 static void *_p_wxSizerTo_p_wxObject(void *x) {
58252 return (void *)((wxObject *) ((wxSizer *) x));
58253 }
58254 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58255 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58256 }
58257 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58258 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58259 }
58260 static void *_p_wxEventTo_p_wxObject(void *x) {
58261 return (void *)((wxObject *) ((wxEvent *) x));
58262 }
58263 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58264 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58265 }
58266 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58267 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58268 }
58269 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58270 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58271 }
58272 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58273 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58274 }
58275 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58276 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58277 }
58278 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58279 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58280 }
58281 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58282 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58283 }
58284 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58285 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58286 }
58287 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58288 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58289 }
58290 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58291 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58292 }
58293 static void *_p_wxControlTo_p_wxObject(void *x) {
58294 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58295 }
58296 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58297 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58298 }
58299 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58300 return (void *)((wxObject *) ((wxFSFile *) x));
58301 }
58302 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58303 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58304 }
58305 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58306 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58307 }
58308 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58309 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58310 }
58311 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58312 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58313 }
58314 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58315 return (void *)((wxObject *) ((wxMenuItem *) x));
58316 }
58317 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58318 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58319 }
58320 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58321 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58322 }
58323 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58324 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58325 }
58326 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58327 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58328 }
58329 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58330 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58331 }
58332 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58333 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58334 }
58335 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58336 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58337 }
58338 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58339 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58340 }
58341 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58342 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58343 }
58344 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58345 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58346 }
58347 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58348 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58349 }
58350 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58351 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58352 }
58353 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58354 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58355 }
58356 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58357 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58358 }
58359 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58360 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58361 }
58362 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58363 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58364 }
58365 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58366 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58367 }
58368 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58369 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58370 }
58371 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58372 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58373 }
58374 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58375 return (void *)((wxObject *) ((wxImageHandler *) x));
58376 }
58377 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58378 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58379 }
58380 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58381 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58382 }
58383 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58384 return (void *)((wxObject *) ((wxEvtHandler *) x));
58385 }
58386 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58387 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58388 }
58389 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58390 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58391 }
58392 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58393 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58394 }
58395 static void *_p_wxImageTo_p_wxObject(void *x) {
58396 return (void *)((wxObject *) ((wxImage *) x));
58397 }
58398 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58399 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58400 }
58401 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58402 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58403 }
58404 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58405 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58406 }
58407 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58408 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58409 }
58410 static void *_p_wxWindowTo_p_wxObject(void *x) {
58411 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58412 }
58413 static void *_p_wxMenuTo_p_wxObject(void *x) {
58414 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58415 }
58416 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58417 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58418 }
58419 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58420 return (void *)((wxObject *) ((wxFileSystem *) x));
58421 }
58422 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58423 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58424 }
58425 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58426 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58427 }
58428 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58429 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58430 }
58431 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58432 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58433 }
58434 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58435 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58436 }
58437 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58438 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58439 }
58440 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58442 }
58443 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58444 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58445 }
58446 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58447 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58448 }
58449 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58450 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58451 }
58452 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58454 }
58455 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58456 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58457 }
58458 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58459 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58460 }
58461 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58462 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58463 }
58464 static void *_p_wxControlTo_p_wxWindow(void *x) {
58465 return (void *)((wxWindow *) ((wxControl *) x));
58466 }
58467 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58468 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58469 }
58470 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58471 return (void *)((wxWindow *) ((wxMenuBar *) x));
58472 }
58473 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58474 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58475 }
58476 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58477 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58478 }
58479 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58480 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58481 }
58482 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58483 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58484 }
58485 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58486 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58487 }
58488 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58489 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58490 }
58491 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58492 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58493 }
58494 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58495 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58496 }
58497 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58498 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58499 }
58500 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58501 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58502 }
58503 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58504 return (void *)((wxValidator *) ((wxPyValidator *) x));
58505 }
58506 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58508 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};
58509 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58640
58641 static swig_type_info *swig_type_initial[] = {
58642 &_swigt__p_buffer,
58643 &_swigt__p_char,
58644 &_swigt__p_form_ops_t,
58645 &_swigt__p_int,
58646 &_swigt__p_long,
58647 &_swigt__p_unsigned_char,
58648 &_swigt__p_unsigned_int,
58649 &_swigt__p_unsigned_long,
58650 &_swigt__p_wxANIHandler,
58651 &_swigt__p_wxAcceleratorEntry,
58652 &_swigt__p_wxAcceleratorTable,
58653 &_swigt__p_wxActivateEvent,
58654 &_swigt__p_wxAppTraits,
58655 &_swigt__p_wxArrayString,
58656 &_swigt__p_wxBMPHandler,
58657 &_swigt__p_wxBitmap,
58658 &_swigt__p_wxBoxSizer,
58659 &_swigt__p_wxButton,
58660 &_swigt__p_wxCURHandler,
58661 &_swigt__p_wxCaret,
58662 &_swigt__p_wxChildFocusEvent,
58663 &_swigt__p_wxClipboardTextEvent,
58664 &_swigt__p_wxCloseEvent,
58665 &_swigt__p_wxColour,
58666 &_swigt__p_wxCommandEvent,
58667 &_swigt__p_wxContextMenuEvent,
58668 &_swigt__p_wxControl,
58669 &_swigt__p_wxControlWithItems,
58670 &_swigt__p_wxCursor,
58671 &_swigt__p_wxDC,
58672 &_swigt__p_wxDateEvent,
58673 &_swigt__p_wxDateTime,
58674 &_swigt__p_wxDisplayChangedEvent,
58675 &_swigt__p_wxDouble,
58676 &_swigt__p_wxDropFilesEvent,
58677 &_swigt__p_wxDuplexMode,
58678 &_swigt__p_wxEraseEvent,
58679 &_swigt__p_wxEvent,
58680 &_swigt__p_wxEventLoop,
58681 &_swigt__p_wxEventLoopActivator,
58682 &_swigt__p_wxEvtHandler,
58683 &_swigt__p_wxFSFile,
58684 &_swigt__p_wxFileSystem,
58685 &_swigt__p_wxFileSystemHandler,
58686 &_swigt__p_wxFlexGridSizer,
58687 &_swigt__p_wxFocusEvent,
58688 &_swigt__p_wxFont,
58689 &_swigt__p_wxFrame,
58690 &_swigt__p_wxGBPosition,
58691 &_swigt__p_wxGBSizerItem,
58692 &_swigt__p_wxGBSpan,
58693 &_swigt__p_wxGIFHandler,
58694 &_swigt__p_wxGridBagSizer,
58695 &_swigt__p_wxGridSizer,
58696 &_swigt__p_wxHelpEvent__Origin,
58697 &_swigt__p_wxICOHandler,
58698 &_swigt__p_wxIconizeEvent,
58699 &_swigt__p_wxIdleEvent,
58700 &_swigt__p_wxImage,
58701 &_swigt__p_wxImageHandler,
58702 &_swigt__p_wxImageHistogram,
58703 &_swigt__p_wxImage_HSVValue,
58704 &_swigt__p_wxImage_RGBValue,
58705 &_swigt__p_wxIndividualLayoutConstraint,
58706 &_swigt__p_wxInitDialogEvent,
58707 &_swigt__p_wxInputStream,
58708 &_swigt__p_wxInternetFSHandler,
58709 &_swigt__p_wxItemContainer,
58710 &_swigt__p_wxJPEGHandler,
58711 &_swigt__p_wxKeyEvent,
58712 &_swigt__p_wxLayoutConstraints,
58713 &_swigt__p_wxMaximizeEvent,
58714 &_swigt__p_wxMemoryFSHandler,
58715 &_swigt__p_wxMenu,
58716 &_swigt__p_wxMenuBar,
58717 &_swigt__p_wxMenuBarBase,
58718 &_swigt__p_wxMenuEvent,
58719 &_swigt__p_wxMenuItem,
58720 &_swigt__p_wxMouseCaptureChangedEvent,
58721 &_swigt__p_wxMouseCaptureLostEvent,
58722 &_swigt__p_wxMouseEvent,
58723 &_swigt__p_wxMoveEvent,
58724 &_swigt__p_wxNavigationKeyEvent,
58725 &_swigt__p_wxNcPaintEvent,
58726 &_swigt__p_wxNotifyEvent,
58727 &_swigt__p_wxObject,
58728 &_swigt__p_wxOutputStream,
58729 &_swigt__p_wxPCXHandler,
58730 &_swigt__p_wxPNGHandler,
58731 &_swigt__p_wxPNMHandler,
58732 &_swigt__p_wxPaintEvent,
58733 &_swigt__p_wxPaletteChangedEvent,
58734 &_swigt__p_wxPaperSize,
58735 &_swigt__p_wxPoint,
58736 &_swigt__p_wxPoint2D,
58737 &_swigt__p_wxPropagateOnce,
58738 &_swigt__p_wxPropagationDisabler,
58739 &_swigt__p_wxPyApp,
58740 &_swigt__p_wxPyCommandEvent,
58741 &_swigt__p_wxPyDropTarget,
58742 &_swigt__p_wxPyEvent,
58743 &_swigt__p_wxPyFileSystemHandler,
58744 &_swigt__p_wxPyImageHandler,
58745 &_swigt__p_wxPyInputStream,
58746 &_swigt__p_wxPySizer,
58747 &_swigt__p_wxPyValidator,
58748 &_swigt__p_wxQuantize,
58749 &_swigt__p_wxQueryNewPaletteEvent,
58750 &_swigt__p_wxRealPoint,
58751 &_swigt__p_wxRect,
58752 &_swigt__p_wxRect2D,
58753 &_swigt__p_wxRegion,
58754 &_swigt__p_wxScrollEvent,
58755 &_swigt__p_wxScrollWinEvent,
58756 &_swigt__p_wxSetCursorEvent,
58757 &_swigt__p_wxShowEvent,
58758 &_swigt__p_wxSize,
58759 &_swigt__p_wxSizeEvent,
58760 &_swigt__p_wxSizer,
58761 &_swigt__p_wxSizerItem,
58762 &_swigt__p_wxStaticBox,
58763 &_swigt__p_wxStaticBoxSizer,
58764 &_swigt__p_wxStdDialogButtonSizer,
58765 &_swigt__p_wxSysColourChangedEvent,
58766 &_swigt__p_wxTIFFHandler,
58767 &_swigt__p_wxToolTip,
58768 &_swigt__p_wxUpdateUIEvent,
58769 &_swigt__p_wxValidator,
58770 &_swigt__p_wxVisualAttributes,
58771 &_swigt__p_wxWindow,
58772 &_swigt__p_wxWindowCreateEvent,
58773 &_swigt__p_wxWindowDestroyEvent,
58774 &_swigt__p_wxXPMHandler,
58775 &_swigt__p_wxZipFSHandler,
58776 };
58777
58778 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58779 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58780 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58788 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58789 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58790 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58791 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58792 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}};
58793 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58794 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}};
58795 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58796 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}};
58797 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58802 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}};
58803 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58804 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}};
58805 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58815 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}};
58816 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58821 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}};
58822 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}};
58823 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58831 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}};
58832 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58833 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}};
58834 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_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},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58845 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}};
58846 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_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_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_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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}};
58864 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58879 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58887 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58896 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}};
58897 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}};
58898 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58905 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}};
58906 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58907 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}};
58908 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58912
58913 static swig_cast_info *swig_cast_initial[] = {
58914 _swigc__p_buffer,
58915 _swigc__p_char,
58916 _swigc__p_form_ops_t,
58917 _swigc__p_int,
58918 _swigc__p_long,
58919 _swigc__p_unsigned_char,
58920 _swigc__p_unsigned_int,
58921 _swigc__p_unsigned_long,
58922 _swigc__p_wxANIHandler,
58923 _swigc__p_wxAcceleratorEntry,
58924 _swigc__p_wxAcceleratorTable,
58925 _swigc__p_wxActivateEvent,
58926 _swigc__p_wxAppTraits,
58927 _swigc__p_wxArrayString,
58928 _swigc__p_wxBMPHandler,
58929 _swigc__p_wxBitmap,
58930 _swigc__p_wxBoxSizer,
58931 _swigc__p_wxButton,
58932 _swigc__p_wxCURHandler,
58933 _swigc__p_wxCaret,
58934 _swigc__p_wxChildFocusEvent,
58935 _swigc__p_wxClipboardTextEvent,
58936 _swigc__p_wxCloseEvent,
58937 _swigc__p_wxColour,
58938 _swigc__p_wxCommandEvent,
58939 _swigc__p_wxContextMenuEvent,
58940 _swigc__p_wxControl,
58941 _swigc__p_wxControlWithItems,
58942 _swigc__p_wxCursor,
58943 _swigc__p_wxDC,
58944 _swigc__p_wxDateEvent,
58945 _swigc__p_wxDateTime,
58946 _swigc__p_wxDisplayChangedEvent,
58947 _swigc__p_wxDouble,
58948 _swigc__p_wxDropFilesEvent,
58949 _swigc__p_wxDuplexMode,
58950 _swigc__p_wxEraseEvent,
58951 _swigc__p_wxEvent,
58952 _swigc__p_wxEventLoop,
58953 _swigc__p_wxEventLoopActivator,
58954 _swigc__p_wxEvtHandler,
58955 _swigc__p_wxFSFile,
58956 _swigc__p_wxFileSystem,
58957 _swigc__p_wxFileSystemHandler,
58958 _swigc__p_wxFlexGridSizer,
58959 _swigc__p_wxFocusEvent,
58960 _swigc__p_wxFont,
58961 _swigc__p_wxFrame,
58962 _swigc__p_wxGBPosition,
58963 _swigc__p_wxGBSizerItem,
58964 _swigc__p_wxGBSpan,
58965 _swigc__p_wxGIFHandler,
58966 _swigc__p_wxGridBagSizer,
58967 _swigc__p_wxGridSizer,
58968 _swigc__p_wxHelpEvent__Origin,
58969 _swigc__p_wxICOHandler,
58970 _swigc__p_wxIconizeEvent,
58971 _swigc__p_wxIdleEvent,
58972 _swigc__p_wxImage,
58973 _swigc__p_wxImageHandler,
58974 _swigc__p_wxImageHistogram,
58975 _swigc__p_wxImage_HSVValue,
58976 _swigc__p_wxImage_RGBValue,
58977 _swigc__p_wxIndividualLayoutConstraint,
58978 _swigc__p_wxInitDialogEvent,
58979 _swigc__p_wxInputStream,
58980 _swigc__p_wxInternetFSHandler,
58981 _swigc__p_wxItemContainer,
58982 _swigc__p_wxJPEGHandler,
58983 _swigc__p_wxKeyEvent,
58984 _swigc__p_wxLayoutConstraints,
58985 _swigc__p_wxMaximizeEvent,
58986 _swigc__p_wxMemoryFSHandler,
58987 _swigc__p_wxMenu,
58988 _swigc__p_wxMenuBar,
58989 _swigc__p_wxMenuBarBase,
58990 _swigc__p_wxMenuEvent,
58991 _swigc__p_wxMenuItem,
58992 _swigc__p_wxMouseCaptureChangedEvent,
58993 _swigc__p_wxMouseCaptureLostEvent,
58994 _swigc__p_wxMouseEvent,
58995 _swigc__p_wxMoveEvent,
58996 _swigc__p_wxNavigationKeyEvent,
58997 _swigc__p_wxNcPaintEvent,
58998 _swigc__p_wxNotifyEvent,
58999 _swigc__p_wxObject,
59000 _swigc__p_wxOutputStream,
59001 _swigc__p_wxPCXHandler,
59002 _swigc__p_wxPNGHandler,
59003 _swigc__p_wxPNMHandler,
59004 _swigc__p_wxPaintEvent,
59005 _swigc__p_wxPaletteChangedEvent,
59006 _swigc__p_wxPaperSize,
59007 _swigc__p_wxPoint,
59008 _swigc__p_wxPoint2D,
59009 _swigc__p_wxPropagateOnce,
59010 _swigc__p_wxPropagationDisabler,
59011 _swigc__p_wxPyApp,
59012 _swigc__p_wxPyCommandEvent,
59013 _swigc__p_wxPyDropTarget,
59014 _swigc__p_wxPyEvent,
59015 _swigc__p_wxPyFileSystemHandler,
59016 _swigc__p_wxPyImageHandler,
59017 _swigc__p_wxPyInputStream,
59018 _swigc__p_wxPySizer,
59019 _swigc__p_wxPyValidator,
59020 _swigc__p_wxQuantize,
59021 _swigc__p_wxQueryNewPaletteEvent,
59022 _swigc__p_wxRealPoint,
59023 _swigc__p_wxRect,
59024 _swigc__p_wxRect2D,
59025 _swigc__p_wxRegion,
59026 _swigc__p_wxScrollEvent,
59027 _swigc__p_wxScrollWinEvent,
59028 _swigc__p_wxSetCursorEvent,
59029 _swigc__p_wxShowEvent,
59030 _swigc__p_wxSize,
59031 _swigc__p_wxSizeEvent,
59032 _swigc__p_wxSizer,
59033 _swigc__p_wxSizerItem,
59034 _swigc__p_wxStaticBox,
59035 _swigc__p_wxStaticBoxSizer,
59036 _swigc__p_wxStdDialogButtonSizer,
59037 _swigc__p_wxSysColourChangedEvent,
59038 _swigc__p_wxTIFFHandler,
59039 _swigc__p_wxToolTip,
59040 _swigc__p_wxUpdateUIEvent,
59041 _swigc__p_wxValidator,
59042 _swigc__p_wxVisualAttributes,
59043 _swigc__p_wxWindow,
59044 _swigc__p_wxWindowCreateEvent,
59045 _swigc__p_wxWindowDestroyEvent,
59046 _swigc__p_wxXPMHandler,
59047 _swigc__p_wxZipFSHandler,
59048 };
59049
59050
59051 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59052
59053 static swig_const_info swig_const_table[] = {
59054 {0, 0, 0, 0.0, 0, 0}};
59055
59056 #ifdef __cplusplus
59057 }
59058 #endif
59059 /* -----------------------------------------------------------------------------
59060 * Type initialization:
59061 * This problem is tough by the requirement that no dynamic
59062 * memory is used. Also, since swig_type_info structures store pointers to
59063 * swig_cast_info structures and swig_cast_info structures store pointers back
59064 * to swig_type_info structures, we need some lookup code at initialization.
59065 * The idea is that swig generates all the structures that are needed.
59066 * The runtime then collects these partially filled structures.
59067 * The SWIG_InitializeModule function takes these initial arrays out of
59068 * swig_module, and does all the lookup, filling in the swig_module.types
59069 * array with the correct data and linking the correct swig_cast_info
59070 * structures together.
59071 *
59072 * The generated swig_type_info structures are assigned staticly to an initial
59073 * array. We just loop though that array, and handle each type individually.
59074 * First we lookup if this type has been already loaded, and if so, use the
59075 * loaded structure instead of the generated one. Then we have to fill in the
59076 * cast linked list. The cast data is initially stored in something like a
59077 * two-dimensional array. Each row corresponds to a type (there are the same
59078 * number of rows as there are in the swig_type_initial array). Each entry in
59079 * a column is one of the swig_cast_info structures for that type.
59080 * The cast_initial array is actually an array of arrays, because each row has
59081 * a variable number of columns. So to actually build the cast linked list,
59082 * we find the array of casts associated with the type, and loop through it
59083 * adding the casts to the list. The one last trick we need to do is making
59084 * sure the type pointer in the swig_cast_info struct is correct.
59085 *
59086 * First off, we lookup the cast->type name to see if it is already loaded.
59087 * There are three cases to handle:
59088 * 1) If the cast->type has already been loaded AND the type we are adding
59089 * casting info to has not been loaded (it is in this module), THEN we
59090 * replace the cast->type pointer with the type pointer that has already
59091 * been loaded.
59092 * 2) If BOTH types (the one we are adding casting info to, and the
59093 * cast->type) are loaded, THEN the cast info has already been loaded by
59094 * the previous module so we just ignore it.
59095 * 3) Finally, if cast->type has not already been loaded, then we add that
59096 * swig_cast_info to the linked list (because the cast->type) pointer will
59097 * be correct.
59098 * ----------------------------------------------------------------------------- */
59099
59100 #ifdef __cplusplus
59101 extern "C" {
59102 #if 0
59103 } /* c-mode */
59104 #endif
59105 #endif
59106
59107 #if 0
59108 #define SWIGRUNTIME_DEBUG
59109 #endif
59110
59111 SWIGRUNTIME void
59112 SWIG_InitializeModule(void *clientdata) {
59113 size_t i;
59114 swig_module_info *module_head;
59115 static int init_run = 0;
59116
59117 clientdata = clientdata;
59118
59119 if (init_run) return;
59120 init_run = 1;
59121
59122 /* Initialize the swig_module */
59123 swig_module.type_initial = swig_type_initial;
59124 swig_module.cast_initial = swig_cast_initial;
59125
59126 /* Try and load any already created modules */
59127 module_head = SWIG_GetModule(clientdata);
59128 if (module_head) {
59129 swig_module.next = module_head->next;
59130 module_head->next = &swig_module;
59131 } else {
59132 /* This is the first module loaded */
59133 swig_module.next = &swig_module;
59134 SWIG_SetModule(clientdata, &swig_module);
59135 }
59136
59137 /* Now work on filling in swig_module.types */
59138 #ifdef SWIGRUNTIME_DEBUG
59139 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59140 #endif
59141 for (i = 0; i < swig_module.size; ++i) {
59142 swig_type_info *type = 0;
59143 swig_type_info *ret;
59144 swig_cast_info *cast;
59145
59146 #ifdef SWIGRUNTIME_DEBUG
59147 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59148 #endif
59149
59150 /* if there is another module already loaded */
59151 if (swig_module.next != &swig_module) {
59152 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59153 }
59154 if (type) {
59155 /* Overwrite clientdata field */
59156 #ifdef SWIGRUNTIME_DEBUG
59157 printf("SWIG_InitializeModule: found type %s\n", type->name);
59158 #endif
59159 if (swig_module.type_initial[i]->clientdata) {
59160 type->clientdata = swig_module.type_initial[i]->clientdata;
59161 #ifdef SWIGRUNTIME_DEBUG
59162 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59163 #endif
59164 }
59165 } else {
59166 type = swig_module.type_initial[i];
59167 }
59168
59169 /* Insert casting types */
59170 cast = swig_module.cast_initial[i];
59171 while (cast->type) {
59172 /* Don't need to add information already in the list */
59173 ret = 0;
59174 #ifdef SWIGRUNTIME_DEBUG
59175 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59176 #endif
59177 if (swig_module.next != &swig_module) {
59178 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59179 #ifdef SWIGRUNTIME_DEBUG
59180 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59181 #endif
59182 }
59183 if (ret) {
59184 if (type == swig_module.type_initial[i]) {
59185 #ifdef SWIGRUNTIME_DEBUG
59186 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59187 #endif
59188 cast->type = ret;
59189 ret = 0;
59190 } else {
59191 /* Check for casting already in the list */
59192 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59193 #ifdef SWIGRUNTIME_DEBUG
59194 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59195 #endif
59196 if (!ocast) ret = 0;
59197 }
59198 }
59199
59200 if (!ret) {
59201 #ifdef SWIGRUNTIME_DEBUG
59202 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59203 #endif
59204 if (type->cast) {
59205 type->cast->prev = cast;
59206 cast->next = type->cast;
59207 }
59208 type->cast = cast;
59209 }
59210 cast++;
59211 }
59212 /* Set entry in modules->types array equal to the type */
59213 swig_module.types[i] = type;
59214 }
59215 swig_module.types[i] = 0;
59216
59217 #ifdef SWIGRUNTIME_DEBUG
59218 printf("**** SWIG_InitializeModule: Cast List ******\n");
59219 for (i = 0; i < swig_module.size; ++i) {
59220 int j = 0;
59221 swig_cast_info *cast = swig_module.cast_initial[i];
59222 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59223 while (cast->type) {
59224 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59225 cast++;
59226 ++j;
59227 }
59228 printf("---- Total casts: %d\n",j);
59229 }
59230 printf("**** SWIG_InitializeModule: Cast List ******\n");
59231 #endif
59232 }
59233
59234 /* This function will propagate the clientdata field of type to
59235 * any new swig_type_info structures that have been added into the list
59236 * of equivalent types. It is like calling
59237 * SWIG_TypeClientData(type, clientdata) a second time.
59238 */
59239 SWIGRUNTIME void
59240 SWIG_PropagateClientData(void) {
59241 size_t i;
59242 swig_cast_info *equiv;
59243 static int init_run = 0;
59244
59245 if (init_run) return;
59246 init_run = 1;
59247
59248 for (i = 0; i < swig_module.size; i++) {
59249 if (swig_module.types[i]->clientdata) {
59250 equiv = swig_module.types[i]->cast;
59251 while (equiv) {
59252 if (!equiv->converter) {
59253 if (equiv->type && !equiv->type->clientdata)
59254 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59255 }
59256 equiv = equiv->next;
59257 }
59258 }
59259 }
59260 }
59261
59262 #ifdef __cplusplus
59263 #if 0
59264 {
59265 /* c-mode */
59266 #endif
59267 }
59268 #endif
59269
59270
59271
59272 #ifdef __cplusplus
59273 extern "C" {
59274 #endif
59275
59276 /* Python-specific SWIG API */
59277 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59278 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59279 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59280
59281 /* -----------------------------------------------------------------------------
59282 * global variable support code.
59283 * ----------------------------------------------------------------------------- */
59284
59285 typedef struct swig_globalvar {
59286 char *name; /* Name of global variable */
59287 PyObject *(*get_attr)(void); /* Return the current value */
59288 int (*set_attr)(PyObject *); /* Set the value */
59289 struct swig_globalvar *next;
59290 } swig_globalvar;
59291
59292 typedef struct swig_varlinkobject {
59293 PyObject_HEAD
59294 swig_globalvar *vars;
59295 } swig_varlinkobject;
59296
59297 SWIGINTERN PyObject *
59298 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59299 return PyString_FromString("<Swig global variables>");
59300 }
59301
59302 SWIGINTERN PyObject *
59303 swig_varlink_str(swig_varlinkobject *v) {
59304 PyObject *str = PyString_FromString("(");
59305 swig_globalvar *var;
59306 for (var = v->vars; var; var=var->next) {
59307 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59308 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59309 }
59310 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59311 return str;
59312 }
59313
59314 SWIGINTERN int
59315 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59316 PyObject *str = swig_varlink_str(v);
59317 fprintf(fp,"Swig global variables ");
59318 fprintf(fp,"%s\n", PyString_AsString(str));
59319 Py_DECREF(str);
59320 return 0;
59321 }
59322
59323 SWIGINTERN void
59324 swig_varlink_dealloc(swig_varlinkobject *v) {
59325 swig_globalvar *var = v->vars;
59326 while (var) {
59327 swig_globalvar *n = var->next;
59328 free(var->name);
59329 free(var);
59330 var = n;
59331 }
59332 }
59333
59334 SWIGINTERN PyObject *
59335 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59336 PyObject *res = NULL;
59337 swig_globalvar *var = v->vars;
59338 while (var) {
59339 if (strcmp(var->name,n) == 0) {
59340 res = (*var->get_attr)();
59341 break;
59342 }
59343 var = var->next;
59344 }
59345 if (res == NULL && !PyErr_Occurred()) {
59346 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59347 }
59348 return res;
59349 }
59350
59351 SWIGINTERN int
59352 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59353 int res = 1;
59354 swig_globalvar *var = v->vars;
59355 while (var) {
59356 if (strcmp(var->name,n) == 0) {
59357 res = (*var->set_attr)(p);
59358 break;
59359 }
59360 var = var->next;
59361 }
59362 if (res == 1 && !PyErr_Occurred()) {
59363 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59364 }
59365 return res;
59366 }
59367
59368 SWIGINTERN PyTypeObject*
59369 swig_varlink_type(void) {
59370 static char varlink__doc__[] = "Swig var link object";
59371 static PyTypeObject varlink_type;
59372 static int type_init = 0;
59373 if (!type_init) {
59374 const PyTypeObject tmp
59375 = {
59376 PyObject_HEAD_INIT(NULL)
59377 0, /* Number of items in variable part (ob_size) */
59378 (char *)"swigvarlink", /* Type name (tp_name) */
59379 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59380 0, /* Itemsize (tp_itemsize) */
59381 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59382 (printfunc) swig_varlink_print, /* Print (tp_print) */
59383 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59384 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59385 0, /* tp_compare */
59386 (reprfunc) swig_varlink_repr, /* tp_repr */
59387 0, /* tp_as_number */
59388 0, /* tp_as_sequence */
59389 0, /* tp_as_mapping */
59390 0, /* tp_hash */
59391 0, /* tp_call */
59392 (reprfunc)swig_varlink_str, /* tp_str */
59393 0, /* tp_getattro */
59394 0, /* tp_setattro */
59395 0, /* tp_as_buffer */
59396 0, /* tp_flags */
59397 varlink__doc__, /* tp_doc */
59398 0, /* tp_traverse */
59399 0, /* tp_clear */
59400 0, /* tp_richcompare */
59401 0, /* tp_weaklistoffset */
59402 #if PY_VERSION_HEX >= 0x02020000
59403 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59404 #endif
59405 #if PY_VERSION_HEX >= 0x02030000
59406 0, /* tp_del */
59407 #endif
59408 #ifdef COUNT_ALLOCS
59409 0,0,0,0 /* tp_alloc -> tp_next */
59410 #endif
59411 };
59412 varlink_type = tmp;
59413 varlink_type.ob_type = &PyType_Type;
59414 type_init = 1;
59415 }
59416 return &varlink_type;
59417 }
59418
59419 /* Create a variable linking object for use later */
59420 SWIGINTERN PyObject *
59421 SWIG_Python_newvarlink(void) {
59422 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59423 if (result) {
59424 result->vars = 0;
59425 }
59426 return ((PyObject*) result);
59427 }
59428
59429 SWIGINTERN void
59430 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59431 swig_varlinkobject *v = (swig_varlinkobject *) p;
59432 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59433 if (gv) {
59434 size_t size = strlen(name)+1;
59435 gv->name = (char *)malloc(size);
59436 if (gv->name) {
59437 strncpy(gv->name,name,size);
59438 gv->get_attr = get_attr;
59439 gv->set_attr = set_attr;
59440 gv->next = v->vars;
59441 }
59442 }
59443 v->vars = gv;
59444 }
59445
59446 SWIGINTERN PyObject *
59447 SWIG_globals() {
59448 static PyObject *_SWIG_globals = 0;
59449 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59450 return _SWIG_globals;
59451 }
59452
59453 /* -----------------------------------------------------------------------------
59454 * constants/methods manipulation
59455 * ----------------------------------------------------------------------------- */
59456
59457 /* Install Constants */
59458 SWIGINTERN void
59459 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59460 PyObject *obj = 0;
59461 size_t i;
59462 for (i = 0; constants[i].type; ++i) {
59463 switch(constants[i].type) {
59464 case SWIG_PY_POINTER:
59465 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59466 break;
59467 case SWIG_PY_BINARY:
59468 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59469 break;
59470 default:
59471 obj = 0;
59472 break;
59473 }
59474 if (obj) {
59475 PyDict_SetItemString(d, constants[i].name, obj);
59476 Py_DECREF(obj);
59477 }
59478 }
59479 }
59480
59481 /* -----------------------------------------------------------------------------*/
59482 /* Fix SwigMethods to carry the callback ptrs when needed */
59483 /* -----------------------------------------------------------------------------*/
59484
59485 SWIGINTERN void
59486 SWIG_Python_FixMethods(PyMethodDef *methods,
59487 swig_const_info *const_table,
59488 swig_type_info **types,
59489 swig_type_info **types_initial) {
59490 size_t i;
59491 for (i = 0; methods[i].ml_name; ++i) {
59492 const char *c = methods[i].ml_doc;
59493 if (c && (c = strstr(c, "swig_ptr: "))) {
59494 int j;
59495 swig_const_info *ci = 0;
59496 const char *name = c + 10;
59497 for (j = 0; const_table[j].type; ++j) {
59498 if (strncmp(const_table[j].name, name,
59499 strlen(const_table[j].name)) == 0) {
59500 ci = &(const_table[j]);
59501 break;
59502 }
59503 }
59504 if (ci) {
59505 size_t shift = (ci->ptype) - types;
59506 swig_type_info *ty = types_initial[shift];
59507 size_t ldoc = (c - methods[i].ml_doc);
59508 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59509 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59510 if (ndoc) {
59511 char *buff = ndoc;
59512 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59513 if (ptr) {
59514 strncpy(buff, methods[i].ml_doc, ldoc);
59515 buff += ldoc;
59516 strncpy(buff, "swig_ptr: ", 10);
59517 buff += 10;
59518 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59519 methods[i].ml_doc = ndoc;
59520 }
59521 }
59522 }
59523 }
59524 }
59525 }
59526
59527 #ifdef __cplusplus
59528 }
59529 #endif
59530
59531 /* -----------------------------------------------------------------------------*
59532 * Partial Init method
59533 * -----------------------------------------------------------------------------*/
59534
59535 #ifdef __cplusplus
59536 extern "C"
59537 #endif
59538 SWIGEXPORT void SWIG_init(void) {
59539 PyObject *m, *d;
59540
59541 /* Fix SwigMethods to carry the callback ptrs when needed */
59542 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59543
59544 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59545 d = PyModule_GetDict(m);
59546
59547 SWIG_InitializeModule(0);
59548 SWIG_InstallConstants(d,swig_const_table);
59549
59550
59551
59552 #ifndef wxPyUSE_EXPORT
59553 // Make our API structure a CObject so other modules can import it
59554 // from this module.
59555 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59556 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59557 Py_XDECREF(cobj);
59558 #endif
59559
59560 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59561 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59562 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59563 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59564 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59565 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59566 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59567 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59568 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59569 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59570 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59571 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59572 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59573 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59574 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59575 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59576 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59577 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59578 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59579 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59580 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59581 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59582 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59583 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59584 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59585 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59586 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59587 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59588 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59589 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59590 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59591 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59592 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59593 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59594 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59595 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59596 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59597 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59598 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59599 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59600 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59601 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59602 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59603 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59604 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59605 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59606 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59607 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59608 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59609 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59610 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59611 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59612 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59613 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59614 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59615 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59616 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59617 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59618 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59619 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59620 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59621 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59622 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59623 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59624 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59625 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59626 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59627 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59628 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59629 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59630 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59631 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59632 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59633 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59634 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59635 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59636 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59637 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59638 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59639 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59640 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59641 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59642 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59643 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59644 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59645 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59646 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59647 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59648 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59649 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59650 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59651 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59652 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59653 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59654 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59655 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59656 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59657 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59658 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59659 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59660 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59661 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59662 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59663 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59664 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59665 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59666 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59667 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59668 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59669 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59670 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59671 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59672 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59673 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59674 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59675 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59676 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59677 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59678 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59679 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59680 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59681 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59682 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59683 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59684 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59685 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59686 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59687 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59688 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59689 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59690 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59691 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59692 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59693 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59694 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59695 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59696 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59697 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59698 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59699 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59700 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59701 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59702 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59703 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59704 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59705 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59706 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59707 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59708 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59709 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59710 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59711 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59712 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59713 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59714 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59715 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59716 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59717 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59718 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59719 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59720 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59721 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59722 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59723 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59724 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59725 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59726 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59727 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59728 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59729 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59730 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59731 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59732 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59733 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59734 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59735 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59736 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59737 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59738 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59739 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59740 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59741 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59742 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59743 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59744 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59745 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59746 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59747 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59748 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59749 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59750 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59751 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59752 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59753 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59754 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59755 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59756 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59757 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59758 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59759 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59760 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59761 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59762 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59763 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59764 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59765 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59766 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59767 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59768 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59769 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59770 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59771 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59772 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59773 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59774 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59775 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59776 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59777 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59778 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59779 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59780 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59781 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59782 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59783 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59784 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59785 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59786 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59787 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59788 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59789 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59790 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59791 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59792 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59793 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59794 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59795 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59796 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59797 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59798 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59799 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59800 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59801 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59802 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59803 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59804 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59805 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59806 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59807 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59808 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59809 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59810 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59811 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59812 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59813 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59814 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59815 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59816 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59817 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59818 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59819 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59820 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59821 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59822 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59823 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59824 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59825 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59826 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59827 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59828 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59829 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59830 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59831 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59832 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59833 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59834 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59835 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59836 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59837 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59838 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59839 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59840 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59841 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59842 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59843 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59844 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59845 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59846 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59847 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59848 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59849 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59850 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59851 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59852 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59853 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59854 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59855 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59856 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59857 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59858 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59859 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59860 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59861 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59862 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59863 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59864 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59865 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59866 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59867 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59868 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59869 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59870 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59871 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59872 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59873 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59874 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59875 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59876 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59877 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59878 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59879 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59880 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59881 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59882 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59883 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59884 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59885 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59886 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59887 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59888 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59889 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59890 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59891 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59892 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59893 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59894 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59895 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59896 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59897 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59898 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59899 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59900 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59901 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59902 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59903 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59904 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59905 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59906 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59907 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59908 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59909 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59910 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59911 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59912 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59913 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59914 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59915 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59916 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59917 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59918 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59919 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59920 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59921 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59922 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59923 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59924 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59925 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59926 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59927 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59928 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59929 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59930 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59931 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59932 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59933 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59934 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59935 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59936 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59937 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59938 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59939 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59940 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59941 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59942 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59943 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59944 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59945 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59946 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59947 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59948 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59949 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59950 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59951 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59952 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59953 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59955 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59956 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59957 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59958 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59959 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59960 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59981 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59982 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59983 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59984 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59985 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59986 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59987 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59988 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59989 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59990 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59991 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59992 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59993 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59994 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59995 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59996 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59997 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59998 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59999 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60000 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60001 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60002 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60003 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60004 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60005 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60006 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60007 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60008 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60009 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60010 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60011 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60012 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60013 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60014 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60015 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60016 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60017 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60018 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60019 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60020 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60021 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60022 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60023 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60024 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60025 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60026 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60027 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60028 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60029 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60030 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60031 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60032 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60033 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60034 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60035 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60036 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60037 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60038 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60039 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60040 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60041 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60042 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60043 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60044 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60045 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60046 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60047 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60048 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60049 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60050 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60051 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60052 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60053 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60054 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60055 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60056 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60057 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60058 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60059 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60060 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60061 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60062 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60063 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60064 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60065 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60066 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60067 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60068 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60069 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60070 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60071 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60072 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60073 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60074 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60075 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60076 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60077 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60078 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60079 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60080 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60081 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60082 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60083 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60084 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60085 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60086 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60087 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60088 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60089 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60090 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60091 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60092 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60093 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60094 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60095 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60096 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60097 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60098 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60099 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60100 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60101 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60102 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60103 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60104 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60105 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60106 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60107 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60108 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60109 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60110 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60111 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60112 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60113 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60114 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60115 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60116 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60117 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60118 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60119 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60120 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60121 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60122 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60123 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60124 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60125 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60126 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60127 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60128 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60129 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60130 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60131 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60132 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60133 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60134 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60135 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60136 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60137 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60138 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60139 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60140 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60141 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60142 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60143 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60144 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60145 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60146 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60147 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60148 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60149 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60150 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60151 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60152 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60153 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60154 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60155 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60156 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60157 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60158 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60159 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60160 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60161 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60162 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60163 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60164 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60165 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60166 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60167 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60173 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60174 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60175 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60176 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60177 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60178 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60179 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60180 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60181 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60183 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60184 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60185 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60186 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60187 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60188 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60189 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60190 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60191 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60192 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60193 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60194 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60195 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60196 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60197 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60198 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60199 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60200 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60201 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60202 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60203 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60204 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60205 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60206 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60207 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60208 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60209 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60210 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60211 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60212 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60213 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60214 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60215 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60216 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60217 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60218 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60219 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60220 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60221 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60222 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60223 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60224
60225 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60226
60227
60228 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60229
60230 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60231 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60232 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60233 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60234 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60235 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60236 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60237 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60238 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60239 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60240 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60241 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60242 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60243 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60244 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60245 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60246 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60247 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60248 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60249 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60250 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60251 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60252 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60253 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60254 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60255 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60256 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60257 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60258 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60259 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60260 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60261 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60262 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60263 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60264 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60265 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60266 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60267 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60268 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60269 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60270 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60271 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60272 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60273 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60274 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60275 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60276 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60277 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60278 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60279 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60280 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60281 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60282 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60283 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60284 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60285 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60286 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60287 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60288 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60289 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60290 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60291 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60292 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60293 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60294 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60295 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60296 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60297 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60298 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60299 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60300 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60301 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60302 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60303 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60304 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60305 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60306 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60307 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60308 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60309 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60310 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60311 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60312 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60313 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60314 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60315 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60316 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60317 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60318 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60319 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60320 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60321 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60322 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60323 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60324 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60325 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60326 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60327 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60328 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60329 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60330 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60331 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60332 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60333 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60334 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60335 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60336 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60337 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60338 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60339 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60340 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60341 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60342 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60343 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60344 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60345 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60346 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60347 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60348 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60349 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60350 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60351 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60352 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60353 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60354 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60355 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60356 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60357 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60358 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60359 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60360 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60361 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60362 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60363 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60364 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60365 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60366 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60367 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60368 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60369 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60370 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60371 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60372 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60373 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60374 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60375 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60376 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60377 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60378 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60379 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60380 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60381 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60382 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60383 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60384 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60385 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60386 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60387 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60388 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60389 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60390 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60391 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60392 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60393 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60394 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60395 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60396 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60397 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60398 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60399 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60400 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60401 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60402 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60403 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60404 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60405 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60406 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60407 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60408 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60409 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60410 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60411 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60412 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60413 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60414 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60415 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60416 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60417 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60418 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60419 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60420 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60421 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60422 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60423 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60424 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60425 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60426 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60427 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60428 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60429 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60430 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60431 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60432 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60433 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60434 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60435 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60436 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60437 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60438 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60439 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60440 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60441 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60442 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60443 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60444
60445 // Initialize threading, some globals and such
60446 __wxPyPreStart(d);
60447
60448
60449 // Although these are defined in __version__ they need to be here too so
60450 // that an assert can be done to ensure that the wxPython and the wxWindows
60451 // versions match.
60452 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60453 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60454 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60455
60456 }
60457
wxWidgets (Impactor)