]> 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
bitwise vs. logical operator
[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_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3834 return wxPyTestDisplayAvailable();
3835 }
3836
3837 void wxApp_CleanUp() {
3838 __wxPyCleanup();
3839 }
3840
3841
3842 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3843
3844
3845
3846
3847
3848 SWIGINTERNINLINE PyObject *
3849 SWIG_FromCharPtr(const char *cptr)
3850 {
3851 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3852 }
3853
3854
3855 #if 0 // #ifdef __WXMAC__
3856
3857 // A dummy class that raises an exception if used...
3858 class wxEventLoop
3859 {
3860 public:
3861 wxEventLoop() { wxPyRaiseNotImplemented(); }
3862 int Run() { return 0; }
3863 void Exit(int rc = 0) {}
3864 bool Pending() const { return false; }
3865 bool Dispatch() { return false; }
3866 bool IsRunning() const { return false; }
3867 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3868 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3869 };
3870
3871 #else
3872
3873 #include <wx/evtloop.h>
3874
3875 #endif
3876
3877
3878
3879 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3880 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3881 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3882 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3883 wxWindowList& list = self->GetChildren();
3884 return wxPy_ConvertList(&list);
3885 }
3886 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3887 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3888 #if wxUSE_HOTKEY
3889 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3890 #else
3891 return false;
3892 #endif
3893 }
3894 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3895
3896
3897
3898 return false;
3899
3900 }
3901 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3902 return wxPyGetWinHandle(self);
3903 }
3904 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3905 self->AssociateHandle((WXWidget)handle);
3906 }
3907
3908 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3909 return wxWindow::FindWindowById(id, parent);
3910 }
3911
3912 wxWindow* wxFindWindowByName( const wxString& name,
3913 const wxWindow *parent = NULL ) {
3914 return wxWindow::FindWindowByName(name, parent);
3915 }
3916
3917 wxWindow* wxFindWindowByLabel( const wxString& label,
3918 const wxWindow *parent = NULL ) {
3919 return wxWindow::FindWindowByLabel(label, parent);
3920 }
3921
3922
3923 #ifdef __WXMSW__
3924 #include <wx/msw/private.h> // to get wxGetWindowId
3925 #endif
3926
3927
3928 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3929 #ifdef __WXMSW__
3930 WXHWND hWnd = (WXHWND)_hWnd;
3931 long id = wxGetWindowId(hWnd);
3932 wxWindow* win = new wxWindow;
3933 if (parent)
3934 parent->AddChild(win);
3935 win->SetEventHandler(win);
3936 win->SetHWND(hWnd);
3937 win->SetId(id);
3938 win->SubclassWin(hWnd);
3939 win->AdoptAttributesFromHWND();
3940 win->SetupColours();
3941 return win;
3942 #else
3943 wxPyRaiseNotImplemented();
3944 return NULL;
3945 #endif
3946 }
3947
3948
3949 PyObject* GetTopLevelWindows() {
3950 return wxPy_ConvertList(&wxTopLevelWindows);
3951 }
3952
3953
3954 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3955 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3957
3958 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3959
3960
3961 SWIGINTERNINLINE int
3962 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3963 {
3964 unsigned long v;
3965 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3966 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3967 return res;
3968 }
3969
3970 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3971 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3972 wxMenuItemList& list = self->GetMenuItems();
3973 return wxPy_ConvertList(&list);
3974 }
3975 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3976 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3977 static const wxString wxPyControlNameStr(wxControlNameStr);
3978 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3979 if (clientData) {
3980 wxPyClientData* data = new wxPyClientData(clientData);
3981 return self->Append(item, data);
3982 } else
3983 return self->Append(item);
3984 }
3985 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3986 if (clientData) {
3987 wxPyClientData* data = new wxPyClientData(clientData);
3988 return self->Insert(item, pos, data);
3989 } else
3990 return self->Insert(item, pos);
3991 }
3992 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3993 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3994 if (data) {
3995 Py_INCREF(data->m_obj);
3996 return data->m_obj;
3997 } else {
3998 Py_INCREF(Py_None);
3999 return Py_None;
4000 }
4001 }
4002 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 self->SetClientObject(n, data);
4005 }
4006
4007
4008 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 return new wxSizerItem(window, proportion, flag, border, data);
4016 }
4017 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4018 wxPyUserData* data = NULL;
4019 if ( userData ) {
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 data = new wxPyUserData(userData);
4022 wxPyEndBlockThreads(blocked);
4023 }
4024 return new wxSizerItem(width, height, proportion, flag, border, data);
4025 }
4026 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4027 wxPyUserData* data = NULL;
4028 if ( userData ) {
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 data = new wxPyUserData(userData);
4031 wxPyEndBlockThreads(blocked);
4032 }
4033 return new wxSizerItem(sizer, proportion, flag, border, data);
4034 }
4035
4036 SWIGINTERNINLINE PyObject *
4037 SWIG_From_float (float value)
4038 {
4039 return SWIG_From_double (value);
4040 }
4041
4042 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4043 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4044 if (data) {
4045 Py_INCREF(data->m_obj);
4046 return data->m_obj;
4047 } else {
4048 Py_INCREF(Py_None);
4049 return Py_None;
4050 }
4051 }
4052 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4053 wxPyUserData* data = NULL;
4054 if ( userData ) {
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 data = new wxPyUserData(userData);
4057 wxPyEndBlockThreads(blocked);
4058 }
4059 self->SetUserData(data);
4060 }
4061
4062 // Figure out the type of the sizer item
4063
4064 struct wxPySizerItemInfo {
4065 wxPySizerItemInfo()
4066 : window(NULL), sizer(NULL), gotSize(false),
4067 size(wxDefaultSize), gotPos(false), pos(-1)
4068 {}
4069
4070 wxWindow* window;
4071 wxSizer* sizer;
4072 bool gotSize;
4073 wxSize size;
4074 bool gotPos;
4075 int pos;
4076 };
4077
4078 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4079
4080 wxPySizerItemInfo info;
4081 wxSize size;
4082 wxSize* sizePtr = &size;
4083
4084 // Find out what the type of the item is
4085 // try wxWindow
4086 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4087 PyErr_Clear();
4088 info.window = NULL;
4089
4090 // try wxSizer
4091 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4092 PyErr_Clear();
4093 info.sizer = NULL;
4094
4095 // try wxSize or (w,h)
4096 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4097 info.size = *sizePtr;
4098 info.gotSize = true;
4099 }
4100
4101 // or a single int
4102 if (checkIdx && PyInt_Check(item)) {
4103 info.pos = PyInt_AsLong(item);
4104 info.gotPos = true;
4105 }
4106 }
4107 }
4108
4109 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4110 // no expected type, figure out what kind of error message to generate
4111 if ( !checkSize && !checkIdx )
4112 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4113 else if ( checkSize && !checkIdx )
4114 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4115 else if ( !checkSize && checkIdx)
4116 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4117 else
4118 // can this one happen?
4119 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4120 }
4121
4122 return info;
4123 }
4124
4125 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4126 if (!self->GetClientObject())
4127 self->SetClientObject(new wxPyOORClientData(_self));
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Add method if a valid item type was found
4141 if ( info.window )
4142 return self->Add(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Add(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4152
4153 wxPyUserData* data = NULL;
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4156 if ( userData && (info.window || info.sizer || info.gotSize) )
4157 data = new wxPyUserData(userData);
4158 if ( info.sizer )
4159 PyObject_SetAttrString(item,"thisown",Py_False);
4160 wxPyEndBlockThreads(blocked);
4161
4162 // Now call the real Insert method if a valid item type was found
4163 if ( info.window )
4164 return self->Insert(before, info.window, proportion, flag, border, data);
4165 else if ( info.sizer )
4166 return self->Insert(before, info.sizer, proportion, flag, border, data);
4167 else if (info.gotSize)
4168 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4169 proportion, flag, border, data);
4170 else
4171 return NULL;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4174
4175 wxPyUserData* data = NULL;
4176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4178 if ( userData && (info.window || info.sizer || info.gotSize) )
4179 data = new wxPyUserData(userData);
4180 if ( info.sizer )
4181 PyObject_SetAttrString(item,"thisown",Py_False);
4182 wxPyEndBlockThreads(blocked);
4183
4184 // Now call the real Prepend method if a valid item type was found
4185 if ( info.window )
4186 return self->Prepend(info.window, proportion, flag, border, data);
4187 else if ( info.sizer )
4188 return self->Prepend(info.sizer, proportion, flag, border, data);
4189 else if (info.gotSize)
4190 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4191 proportion, flag, border, data);
4192 else
4193 return NULL;
4194 }
4195 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4198 wxPyEndBlockThreads(blocked);
4199 if ( info.window )
4200 return self->Remove(info.window);
4201 else if ( info.sizer )
4202 return self->Remove(info.sizer);
4203 else if ( info.gotPos )
4204 return self->Remove(info.pos);
4205 else
4206 return false;
4207 }
4208 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4211 wxPyEndBlockThreads(blocked);
4212 if ( info.window )
4213 return self->Detach(info.window);
4214 else if ( info.sizer )
4215 return self->Detach(info.sizer);
4216 else if ( info.gotPos )
4217 return self->Detach(info.pos);
4218 else
4219 return false;
4220 }
4221 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->GetItem(info.window);
4227 else if ( info.sizer )
4228 return self->GetItem(info.sizer);
4229 else if ( info.gotPos )
4230 return self->GetItem(info.pos);
4231 else
4232 return NULL;
4233 }
4234 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 self->SetItemMinSize(info.window, size);
4240 else if ( info.sizer )
4241 self->SetItemMinSize(info.sizer, size);
4242 else if ( info.gotPos )
4243 self->SetItemMinSize(info.pos, size);
4244 }
4245 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4246 wxSizerItemList& list = self->GetChildren();
4247 return wxPy_ConvertList(&list);
4248 }
4249 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4252 wxPyEndBlockThreads(blocked);
4253 if ( info.window )
4254 return self->Show(info.window, show, recursive);
4255 else if ( info.sizer )
4256 return self->Show(info.sizer, show, recursive);
4257 else if ( info.gotPos )
4258 return self->Show(info.pos, show);
4259 else
4260 return false;
4261 }
4262 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4264 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4265 wxPyEndBlockThreads(blocked);
4266 if ( info.window )
4267 return self->IsShown(info.window);
4268 else if ( info.sizer )
4269 return self->IsShown(info.sizer);
4270 else if ( info.gotPos )
4271 return self->IsShown(info.pos);
4272 else
4273 return false;
4274 }
4275
4276 // See pyclasses.h
4277 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4278 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4279 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4280
4281
4282
4283
4284 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4285 {
4286 if (source == Py_None) {
4287 **obj = wxGBPosition(-1,-1);
4288 return true;
4289 }
4290 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4291 }
4292
4293 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4294 {
4295 if (source == Py_None) {
4296 **obj = wxGBSpan(-1,-1);
4297 return true;
4298 }
4299 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4300 }
4301
4302
4303 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4304 wxGBPosition temp, *obj = &temp;
4305 if ( other == Py_None ) return false;
4306 if ( ! wxGBPosition_helper(other, &obj) ) {
4307 PyErr_Clear();
4308 return false;
4309 }
4310 return self->operator==(*obj);
4311 }
4312 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4313 wxGBPosition temp, *obj = &temp;
4314 if ( other == Py_None ) return true;
4315 if ( ! wxGBPosition_helper(other, &obj)) {
4316 PyErr_Clear();
4317 return true;
4318 }
4319 return self->operator!=(*obj);
4320 }
4321 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4322 self->SetRow(row);
4323 self->SetCol(col);
4324 }
4325 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 PyObject* tup = PyTuple_New(2);
4328 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4329 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4330 wxPyEndBlockThreads(blocked);
4331 return tup;
4332 }
4333 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4334 wxGBSpan temp, *obj = &temp;
4335 if ( other == Py_None ) return false;
4336 if ( ! wxGBSpan_helper(other, &obj) ) {
4337 PyErr_Clear();
4338 return false;
4339 }
4340 return self->operator==(*obj);
4341 }
4342 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4343 wxGBSpan temp, *obj = &temp;
4344 if ( other == Py_None ) return true;
4345 if ( ! wxGBSpan_helper(other, &obj)) {
4346 PyErr_Clear();
4347 return true;
4348 }
4349 return self->operator!=(*obj);
4350 }
4351 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4352 self->SetRowspan(rowspan);
4353 self->SetColspan(colspan);
4354 }
4355 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 PyObject* tup = PyTuple_New(2);
4358 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4359 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4360 wxPyEndBlockThreads(blocked);
4361 return tup;
4362 }
4363 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4364 wxPyUserData* data = NULL;
4365 if ( userData ) {
4366 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4367 data = new wxPyUserData(userData);
4368 wxPyEndBlockThreads(blocked);
4369 }
4370 return new wxGBSizerItem(window, pos, span, flag, border, data);
4371 }
4372 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4373 wxPyUserData* data = NULL;
4374 if ( userData ) {
4375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4376 data = new wxPyUserData(userData);
4377 wxPyEndBlockThreads(blocked);
4378 }
4379 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4380 }
4381 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4382 wxPyUserData* data = NULL;
4383 if ( userData ) {
4384 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4385 data = new wxPyUserData(userData);
4386 wxPyEndBlockThreads(blocked);
4387 }
4388 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4389 }
4390 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4391 int row, col;
4392 self->GetEndPos(row, col);
4393 return wxGBPosition(row, col);
4394 }
4395 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4396
4397 wxPyUserData* data = NULL;
4398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4399 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4400 if ( userData && (info.window || info.sizer || info.gotSize) )
4401 data = new wxPyUserData(userData);
4402 if ( info.sizer )
4403 PyObject_SetAttrString(item,"thisown",Py_False);
4404 wxPyEndBlockThreads(blocked);
4405
4406 // Now call the real Add method if a valid item type was found
4407 if ( info.window )
4408 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4409 else if ( info.sizer )
4410 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4411 else if (info.gotSize)
4412 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4413 pos, span, flag, border, data);
4414 return NULL;
4415 }
4416
4417
4418 #ifdef __cplusplus
4419 extern "C" {
4420 #endif
4421 SWIGINTERN int EmptyString_set(PyObject *) {
4422 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4423 return 1;
4424 }
4425
4426
4427 SWIGINTERN PyObject *EmptyString_get(void) {
4428 PyObject *pyobj = 0;
4429
4430 {
4431 #if wxUSE_UNICODE
4432 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4433 #else
4434 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4435 #endif
4436 }
4437 return pyobj;
4438 }
4439
4440
4441 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442 PyObject *resultobj = 0;
4443 wxObject *arg1 = (wxObject *) 0 ;
4444 wxString result;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 PyObject *swig_obj[1] ;
4448
4449 if (!args) SWIG_fail;
4450 swig_obj[0] = args;
4451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4452 if (!SWIG_IsOK(res1)) {
4453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4454 }
4455 arg1 = reinterpret_cast< wxObject * >(argp1);
4456 {
4457 PyThreadState* __tstate = wxPyBeginAllowThreads();
4458 result = wxObject_GetClassName(arg1);
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 {
4463 #if wxUSE_UNICODE
4464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4465 #else
4466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4467 #endif
4468 }
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxObject *arg1 = (wxObject *) 0 ;
4478 void *argp1 = 0 ;
4479 int res1 = 0 ;
4480 PyObject *swig_obj[1] ;
4481
4482 if (!args) SWIG_fail;
4483 swig_obj[0] = args;
4484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4485 if (!SWIG_IsOK(res1)) {
4486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4487 }
4488 arg1 = reinterpret_cast< wxObject * >(argp1);
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 wxObject_Destroy(arg1);
4492 wxPyEndAllowThreads(__tstate);
4493 if (PyErr_Occurred()) SWIG_fail;
4494 }
4495 resultobj = SWIG_Py_Void();
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxObject *arg1 = (wxObject *) 0 ;
4505 wxObject *arg2 = 0 ;
4506 bool result;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 void *argp2 = 0 ;
4510 int res2 = 0 ;
4511 PyObject * obj0 = 0 ;
4512 PyObject * obj1 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "self",(char *) "p", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4519 if (!SWIG_IsOK(res1)) {
4520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4521 }
4522 arg1 = reinterpret_cast< wxObject * >(argp1);
4523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4524 if (!SWIG_IsOK(res2)) {
4525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4526 }
4527 if (!argp2) {
4528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4529 }
4530 arg2 = reinterpret_cast< wxObject * >(argp2);
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4547 PyObject *obj;
4548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4549 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4550 return SWIG_Py_Void();
4551 }
4552
4553 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 PyObject *resultobj = 0;
4555 wxSize *arg1 = (wxSize *) 0 ;
4556 int arg2 ;
4557 void *argp1 = 0 ;
4558 int res1 = 0 ;
4559 int val2 ;
4560 int ecode2 = 0 ;
4561 PyObject *swig_obj[2] ;
4562
4563 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4567 }
4568 arg1 = reinterpret_cast< wxSize * >(argp1);
4569 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4570 if (!SWIG_IsOK(ecode2)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4572 }
4573 arg2 = static_cast< int >(val2);
4574 if (arg1) (arg1)->x = arg2;
4575
4576 resultobj = SWIG_Py_Void();
4577 return resultobj;
4578 fail:
4579 return NULL;
4580 }
4581
4582
4583 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4584 PyObject *resultobj = 0;
4585 wxSize *arg1 = (wxSize *) 0 ;
4586 int result;
4587 void *argp1 = 0 ;
4588 int res1 = 0 ;
4589 PyObject *swig_obj[1] ;
4590
4591 if (!args) SWIG_fail;
4592 swig_obj[0] = args;
4593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 result = (int) ((arg1)->x);
4599 resultobj = SWIG_From_int(static_cast< int >(result));
4600 return resultobj;
4601 fail:
4602 return NULL;
4603 }
4604
4605
4606 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *resultobj = 0;
4608 wxSize *arg1 = (wxSize *) 0 ;
4609 int arg2 ;
4610 void *argp1 = 0 ;
4611 int res1 = 0 ;
4612 int val2 ;
4613 int ecode2 = 0 ;
4614 PyObject *swig_obj[2] ;
4615
4616 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4618 if (!SWIG_IsOK(res1)) {
4619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4620 }
4621 arg1 = reinterpret_cast< wxSize * >(argp1);
4622 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4623 if (!SWIG_IsOK(ecode2)) {
4624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4625 }
4626 arg2 = static_cast< int >(val2);
4627 if (arg1) (arg1)->y = arg2;
4628
4629 resultobj = SWIG_Py_Void();
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4637 PyObject *resultobj = 0;
4638 wxSize *arg1 = (wxSize *) 0 ;
4639 int result;
4640 void *argp1 = 0 ;
4641 int res1 = 0 ;
4642 PyObject *swig_obj[1] ;
4643
4644 if (!args) SWIG_fail;
4645 swig_obj[0] = args;
4646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4647 if (!SWIG_IsOK(res1)) {
4648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4649 }
4650 arg1 = reinterpret_cast< wxSize * >(argp1);
4651 result = (int) ((arg1)->y);
4652 resultobj = SWIG_From_int(static_cast< int >(result));
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 int arg1 = (int) 0 ;
4662 int arg2 = (int) 0 ;
4663 wxSize *result = 0 ;
4664 int val1 ;
4665 int ecode1 = 0 ;
4666 int val2 ;
4667 int ecode2 = 0 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 char * kwnames[] = {
4671 (char *) "w",(char *) "h", NULL
4672 };
4673
4674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4675 if (obj0) {
4676 ecode1 = SWIG_AsVal_int(obj0, &val1);
4677 if (!SWIG_IsOK(ecode1)) {
4678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4679 }
4680 arg1 = static_cast< int >(val1);
4681 }
4682 if (obj1) {
4683 ecode2 = SWIG_AsVal_int(obj1, &val2);
4684 if (!SWIG_IsOK(ecode2)) {
4685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4686 }
4687 arg2 = static_cast< int >(val2);
4688 }
4689 {
4690 result = (wxSize *)new wxSize(arg1,arg2);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4701 PyObject *resultobj = 0;
4702 wxSize *arg1 = (wxSize *) 0 ;
4703 void *argp1 = 0 ;
4704 int res1 = 0 ;
4705 PyObject *swig_obj[1] ;
4706
4707 if (!args) SWIG_fail;
4708 swig_obj[0] = args;
4709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4710 if (!SWIG_IsOK(res1)) {
4711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4712 }
4713 arg1 = reinterpret_cast< wxSize * >(argp1);
4714 {
4715 delete arg1;
4716
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = SWIG_Py_Void();
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 PyObject *arg2 = (PyObject *) 0 ;
4730 bool result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "other", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 arg2 = obj1;
4746 {
4747 result = (bool)wxSize___eq__(arg1,arg2);
4748 if (PyErr_Occurred()) SWIG_fail;
4749 }
4750 {
4751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4752 }
4753 return resultobj;
4754 fail:
4755 return NULL;
4756 }
4757
4758
4759 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4760 PyObject *resultobj = 0;
4761 wxSize *arg1 = (wxSize *) 0 ;
4762 PyObject *arg2 = (PyObject *) 0 ;
4763 bool result;
4764 void *argp1 = 0 ;
4765 int res1 = 0 ;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 char * kwnames[] = {
4769 (char *) "self",(char *) "other", NULL
4770 };
4771
4772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4774 if (!SWIG_IsOK(res1)) {
4775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4776 }
4777 arg1 = reinterpret_cast< wxSize * >(argp1);
4778 arg2 = obj1;
4779 {
4780 result = (bool)wxSize___ne__(arg1,arg2);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 {
4784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4785 }
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj = 0;
4794 wxSize *arg1 = (wxSize *) 0 ;
4795 wxSize *arg2 = 0 ;
4796 wxSize result;
4797 void *argp1 = 0 ;
4798 int res1 = 0 ;
4799 wxSize temp2 ;
4800 PyObject * obj0 = 0 ;
4801 PyObject * obj1 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "self",(char *) "sz", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4808 if (!SWIG_IsOK(res1)) {
4809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4810 }
4811 arg1 = reinterpret_cast< wxSize * >(argp1);
4812 {
4813 arg2 = &temp2;
4814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4815 }
4816 {
4817 result = (arg1)->operator +((wxSize const &)*arg2);
4818 if (PyErr_Occurred()) SWIG_fail;
4819 }
4820 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4821 return resultobj;
4822 fail:
4823 return NULL;
4824 }
4825
4826
4827 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4828 PyObject *resultobj = 0;
4829 wxSize *arg1 = (wxSize *) 0 ;
4830 wxSize *arg2 = 0 ;
4831 wxSize result;
4832 void *argp1 = 0 ;
4833 int res1 = 0 ;
4834 wxSize temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char * kwnames[] = {
4838 (char *) "self",(char *) "sz", NULL
4839 };
4840
4841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4843 if (!SWIG_IsOK(res1)) {
4844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4845 }
4846 arg1 = reinterpret_cast< wxSize * >(argp1);
4847 {
4848 arg2 = &temp2;
4849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4850 }
4851 {
4852 result = (arg1)->operator -((wxSize const &)*arg2);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4863 PyObject *resultobj = 0;
4864 wxSize *arg1 = (wxSize *) 0 ;
4865 wxSize *arg2 = 0 ;
4866 void *argp1 = 0 ;
4867 int res1 = 0 ;
4868 wxSize temp2 ;
4869 PyObject * obj0 = 0 ;
4870 PyObject * obj1 = 0 ;
4871 char * kwnames[] = {
4872 (char *) "self",(char *) "sz", NULL
4873 };
4874
4875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4877 if (!SWIG_IsOK(res1)) {
4878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4879 }
4880 arg1 = reinterpret_cast< wxSize * >(argp1);
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 {
4886 (arg1)->IncTo((wxSize const &)*arg2);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 wxSize *arg1 = (wxSize *) 0 ;
4899 wxSize *arg2 = 0 ;
4900 void *argp1 = 0 ;
4901 int res1 = 0 ;
4902 wxSize temp2 ;
4903 PyObject * obj0 = 0 ;
4904 PyObject * obj1 = 0 ;
4905 char * kwnames[] = {
4906 (char *) "self",(char *) "sz", NULL
4907 };
4908
4909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4911 if (!SWIG_IsOK(res1)) {
4912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4913 }
4914 arg1 = reinterpret_cast< wxSize * >(argp1);
4915 {
4916 arg2 = &temp2;
4917 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4918 }
4919 {
4920 (arg1)->DecTo((wxSize const &)*arg2);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 resultobj = SWIG_Py_Void();
4924 return resultobj;
4925 fail:
4926 return NULL;
4927 }
4928
4929
4930 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj = 0;
4932 wxSize *arg1 = (wxSize *) 0 ;
4933 int arg2 ;
4934 int arg3 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 int val2 ;
4938 int ecode2 = 0 ;
4939 int val3 ;
4940 int ecode3 = 0 ;
4941 PyObject * obj0 = 0 ;
4942 PyObject * obj1 = 0 ;
4943 PyObject * obj2 = 0 ;
4944 char * kwnames[] = {
4945 (char *) "self",(char *) "dx",(char *) "dy", NULL
4946 };
4947
4948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4952 }
4953 arg1 = reinterpret_cast< wxSize * >(argp1);
4954 ecode2 = SWIG_AsVal_int(obj1, &val2);
4955 if (!SWIG_IsOK(ecode2)) {
4956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4957 }
4958 arg2 = static_cast< int >(val2);
4959 ecode3 = SWIG_AsVal_int(obj2, &val3);
4960 if (!SWIG_IsOK(ecode3)) {
4961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4962 }
4963 arg3 = static_cast< int >(val3);
4964 {
4965 (arg1)->IncBy(arg2,arg3);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_Py_Void();
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj = 0;
4977 wxSize *arg1 = (wxSize *) 0 ;
4978 int arg2 ;
4979 int arg3 ;
4980 void *argp1 = 0 ;
4981 int res1 = 0 ;
4982 int val2 ;
4983 int ecode2 = 0 ;
4984 int val3 ;
4985 int ecode3 = 0 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 PyObject * obj2 = 0 ;
4989 char * kwnames[] = {
4990 (char *) "self",(char *) "dx",(char *) "dy", NULL
4991 };
4992
4993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4995 if (!SWIG_IsOK(res1)) {
4996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4997 }
4998 arg1 = reinterpret_cast< wxSize * >(argp1);
4999 ecode2 = SWIG_AsVal_int(obj1, &val2);
5000 if (!SWIG_IsOK(ecode2)) {
5001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5002 }
5003 arg2 = static_cast< int >(val2);
5004 ecode3 = SWIG_AsVal_int(obj2, &val3);
5005 if (!SWIG_IsOK(ecode3)) {
5006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5007 }
5008 arg3 = static_cast< int >(val3);
5009 {
5010 (arg1)->DecBy(arg2,arg3);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 float arg2 ;
5024 float arg3 ;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 float val2 ;
5028 int ecode2 = 0 ;
5029 float val3 ;
5030 int ecode3 = 0 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 PyObject * obj2 = 0 ;
5034 char * kwnames[] = {
5035 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5036 };
5037
5038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5040 if (!SWIG_IsOK(res1)) {
5041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5042 }
5043 arg1 = reinterpret_cast< wxSize * >(argp1);
5044 ecode2 = SWIG_AsVal_float(obj1, &val2);
5045 if (!SWIG_IsOK(ecode2)) {
5046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5047 }
5048 arg2 = static_cast< float >(val2);
5049 ecode3 = SWIG_AsVal_float(obj2, &val3);
5050 if (!SWIG_IsOK(ecode3)) {
5051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5052 }
5053 arg3 = static_cast< float >(val3);
5054 {
5055 (arg1)->Scale(arg2,arg3);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 resultobj = SWIG_Py_Void();
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj = 0;
5067 wxSize *arg1 = (wxSize *) 0 ;
5068 int arg2 ;
5069 int arg3 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 int val2 ;
5073 int ecode2 = 0 ;
5074 int val3 ;
5075 int ecode3 = 0 ;
5076 PyObject * obj0 = 0 ;
5077 PyObject * obj1 = 0 ;
5078 PyObject * obj2 = 0 ;
5079 char * kwnames[] = {
5080 (char *) "self",(char *) "w",(char *) "h", NULL
5081 };
5082
5083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5087 }
5088 arg1 = reinterpret_cast< wxSize * >(argp1);
5089 ecode2 = SWIG_AsVal_int(obj1, &val2);
5090 if (!SWIG_IsOK(ecode2)) {
5091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5092 }
5093 arg2 = static_cast< int >(val2);
5094 ecode3 = SWIG_AsVal_int(obj2, &val3);
5095 if (!SWIG_IsOK(ecode3)) {
5096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5097 }
5098 arg3 = static_cast< int >(val3);
5099 {
5100 (arg1)->Set(arg2,arg3);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_Py_Void();
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 int arg2 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 int val2 ;
5117 int ecode2 = 0 ;
5118 PyObject * obj0 = 0 ;
5119 PyObject * obj1 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "self",(char *) "w", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5128 }
5129 arg1 = reinterpret_cast< wxSize * >(argp1);
5130 ecode2 = SWIG_AsVal_int(obj1, &val2);
5131 if (!SWIG_IsOK(ecode2)) {
5132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5133 }
5134 arg2 = static_cast< int >(val2);
5135 {
5136 (arg1)->SetWidth(arg2);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 int arg2 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 int val2 ;
5153 int ecode2 = 0 ;
5154 PyObject * obj0 = 0 ;
5155 PyObject * obj1 = 0 ;
5156 char * kwnames[] = {
5157 (char *) "self",(char *) "h", NULL
5158 };
5159
5160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5162 if (!SWIG_IsOK(res1)) {
5163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5164 }
5165 arg1 = reinterpret_cast< wxSize * >(argp1);
5166 ecode2 = SWIG_AsVal_int(obj1, &val2);
5167 if (!SWIG_IsOK(ecode2)) {
5168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5169 }
5170 arg2 = static_cast< int >(val2);
5171 {
5172 (arg1)->SetHeight(arg2);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 resultobj = SWIG_Py_Void();
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxSize *arg1 = (wxSize *) 0 ;
5185 int result;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 PyObject *swig_obj[1] ;
5189
5190 if (!args) SWIG_fail;
5191 swig_obj[0] = args;
5192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5195 }
5196 arg1 = reinterpret_cast< wxSize * >(argp1);
5197 {
5198 result = (int)((wxSize const *)arg1)->GetWidth();
5199 if (PyErr_Occurred()) SWIG_fail;
5200 }
5201 resultobj = SWIG_From_int(static_cast< int >(result));
5202 return resultobj;
5203 fail:
5204 return NULL;
5205 }
5206
5207
5208 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5209 PyObject *resultobj = 0;
5210 wxSize *arg1 = (wxSize *) 0 ;
5211 int result;
5212 void *argp1 = 0 ;
5213 int res1 = 0 ;
5214 PyObject *swig_obj[1] ;
5215
5216 if (!args) SWIG_fail;
5217 swig_obj[0] = args;
5218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5219 if (!SWIG_IsOK(res1)) {
5220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5221 }
5222 arg1 = reinterpret_cast< wxSize * >(argp1);
5223 {
5224 result = (int)((wxSize const *)arg1)->GetHeight();
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 resultobj = SWIG_From_int(static_cast< int >(result));
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5235 PyObject *resultobj = 0;
5236 wxSize *arg1 = (wxSize *) 0 ;
5237 bool result;
5238 void *argp1 = 0 ;
5239 int res1 = 0 ;
5240 PyObject *swig_obj[1] ;
5241
5242 if (!args) SWIG_fail;
5243 swig_obj[0] = args;
5244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5245 if (!SWIG_IsOK(res1)) {
5246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5247 }
5248 arg1 = reinterpret_cast< wxSize * >(argp1);
5249 {
5250 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 {
5254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5255 }
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 wxSize *arg1 = (wxSize *) 0 ;
5265 wxSize *arg2 = 0 ;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 wxSize temp2 ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "size", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5279 }
5280 arg1 = reinterpret_cast< wxSize * >(argp1);
5281 {
5282 arg2 = &temp2;
5283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5284 }
5285 {
5286 (arg1)->SetDefaults((wxSize const &)*arg2);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 resultobj = SWIG_Py_Void();
5290 return resultobj;
5291 fail:
5292 return NULL;
5293 }
5294
5295
5296 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxSize *arg1 = (wxSize *) 0 ;
5299 PyObject *result = 0 ;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 PyObject *swig_obj[1] ;
5303
5304 if (!args) SWIG_fail;
5305 swig_obj[0] = args;
5306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5307 if (!SWIG_IsOK(res1)) {
5308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5309 }
5310 arg1 = reinterpret_cast< wxSize * >(argp1);
5311 {
5312 result = (PyObject *)wxSize_Get(arg1);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 resultobj = result;
5316 return resultobj;
5317 fail:
5318 return NULL;
5319 }
5320
5321
5322 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5323 PyObject *obj;
5324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5325 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5326 return SWIG_Py_Void();
5327 }
5328
5329 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 return SWIG_Python_InitShadowInstance(args);
5331 }
5332
5333 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5334 PyObject *resultobj = 0;
5335 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5336 double arg2 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 double val2 ;
5340 int ecode2 = 0 ;
5341 PyObject *swig_obj[2] ;
5342
5343 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5350 if (!SWIG_IsOK(ecode2)) {
5351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5352 }
5353 arg2 = static_cast< double >(val2);
5354 if (arg1) (arg1)->x = arg2;
5355
5356 resultobj = SWIG_Py_Void();
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 double result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject *swig_obj[1] ;
5370
5371 if (!args) SWIG_fail;
5372 swig_obj[0] = args;
5373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5376 }
5377 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5378 result = (double) ((arg1)->x);
5379 resultobj = SWIG_From_double(static_cast< double >(result));
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5387 PyObject *resultobj = 0;
5388 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5389 double arg2 ;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 double val2 ;
5393 int ecode2 = 0 ;
5394 PyObject *swig_obj[2] ;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5398 if (!SWIG_IsOK(res1)) {
5399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5400 }
5401 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5402 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5403 if (!SWIG_IsOK(ecode2)) {
5404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5405 }
5406 arg2 = static_cast< double >(val2);
5407 if (arg1) (arg1)->y = arg2;
5408
5409 resultobj = SWIG_Py_Void();
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5419 double result;
5420 void *argp1 = 0 ;
5421 int res1 = 0 ;
5422 PyObject *swig_obj[1] ;
5423
5424 if (!args) SWIG_fail;
5425 swig_obj[0] = args;
5426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5427 if (!SWIG_IsOK(res1)) {
5428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5429 }
5430 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5431 result = (double) ((arg1)->y);
5432 resultobj = SWIG_From_double(static_cast< double >(result));
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 double arg1 = (double) 0.0 ;
5442 double arg2 = (double) 0.0 ;
5443 wxRealPoint *result = 0 ;
5444 double val1 ;
5445 int ecode1 = 0 ;
5446 double val2 ;
5447 int ecode2 = 0 ;
5448 PyObject * obj0 = 0 ;
5449 PyObject * obj1 = 0 ;
5450 char * kwnames[] = {
5451 (char *) "x",(char *) "y", NULL
5452 };
5453
5454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5455 if (obj0) {
5456 ecode1 = SWIG_AsVal_double(obj0, &val1);
5457 if (!SWIG_IsOK(ecode1)) {
5458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5459 }
5460 arg1 = static_cast< double >(val1);
5461 }
5462 if (obj1) {
5463 ecode2 = SWIG_AsVal_double(obj1, &val2);
5464 if (!SWIG_IsOK(ecode2)) {
5465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5466 }
5467 arg2 = static_cast< double >(val2);
5468 }
5469 {
5470 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 void *argp1 = 0 ;
5484 int res1 = 0 ;
5485 PyObject *swig_obj[1] ;
5486
5487 if (!args) SWIG_fail;
5488 swig_obj[0] = args;
5489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5490 if (!SWIG_IsOK(res1)) {
5491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5492 }
5493 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5494 {
5495 delete arg1;
5496
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 PyObject *arg2 = (PyObject *) 0 ;
5510 bool result;
5511 void *argp1 = 0 ;
5512 int res1 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char * kwnames[] = {
5516 (char *) "self",(char *) "other", NULL
5517 };
5518
5519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5521 if (!SWIG_IsOK(res1)) {
5522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5523 }
5524 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5525 arg2 = obj1;
5526 {
5527 result = (bool)wxRealPoint___eq__(arg1,arg2);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj = 0;
5541 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5542 PyObject *arg2 = (PyObject *) 0 ;
5543 bool result;
5544 void *argp1 = 0 ;
5545 int res1 = 0 ;
5546 PyObject * obj0 = 0 ;
5547 PyObject * obj1 = 0 ;
5548 char * kwnames[] = {
5549 (char *) "self",(char *) "other", NULL
5550 };
5551
5552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5554 if (!SWIG_IsOK(res1)) {
5555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5556 }
5557 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5558 arg2 = obj1;
5559 {
5560 result = (bool)wxRealPoint___ne__(arg1,arg2);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 {
5564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5565 }
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5573 PyObject *resultobj = 0;
5574 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5575 wxRealPoint *arg2 = 0 ;
5576 wxRealPoint result;
5577 void *argp1 = 0 ;
5578 int res1 = 0 ;
5579 wxRealPoint temp2 ;
5580 PyObject * obj0 = 0 ;
5581 PyObject * obj1 = 0 ;
5582 char * kwnames[] = {
5583 (char *) "self",(char *) "pt", NULL
5584 };
5585
5586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5588 if (!SWIG_IsOK(res1)) {
5589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5590 }
5591 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5592 {
5593 arg2 = &temp2;
5594 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5595 }
5596 {
5597 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5601 return resultobj;
5602 fail:
5603 return NULL;
5604 }
5605
5606
5607 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj = 0;
5609 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5610 wxRealPoint *arg2 = 0 ;
5611 wxRealPoint result;
5612 void *argp1 = 0 ;
5613 int res1 = 0 ;
5614 wxRealPoint temp2 ;
5615 PyObject * obj0 = 0 ;
5616 PyObject * obj1 = 0 ;
5617 char * kwnames[] = {
5618 (char *) "self",(char *) "pt", NULL
5619 };
5620
5621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5623 if (!SWIG_IsOK(res1)) {
5624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5625 }
5626 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5627 {
5628 arg2 = &temp2;
5629 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5630 }
5631 {
5632 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = 0;
5644 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5645 double arg2 ;
5646 double arg3 ;
5647 void *argp1 = 0 ;
5648 int res1 = 0 ;
5649 double val2 ;
5650 int ecode2 = 0 ;
5651 double val3 ;
5652 int ecode3 = 0 ;
5653 PyObject * obj0 = 0 ;
5654 PyObject * obj1 = 0 ;
5655 PyObject * obj2 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "self",(char *) "x",(char *) "y", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5662 if (!SWIG_IsOK(res1)) {
5663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5664 }
5665 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5666 ecode2 = SWIG_AsVal_double(obj1, &val2);
5667 if (!SWIG_IsOK(ecode2)) {
5668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5669 }
5670 arg2 = static_cast< double >(val2);
5671 ecode3 = SWIG_AsVal_double(obj2, &val3);
5672 if (!SWIG_IsOK(ecode3)) {
5673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5674 }
5675 arg3 = static_cast< double >(val3);
5676 {
5677 wxRealPoint_Set(arg1,arg2,arg3);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5690 PyObject *result = 0 ;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5702 {
5703 result = (PyObject *)wxRealPoint_Get(arg1);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = result;
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5714 PyObject *obj;
5715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5716 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5717 return SWIG_Py_Void();
5718 }
5719
5720 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5721 return SWIG_Python_InitShadowInstance(args);
5722 }
5723
5724 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5725 PyObject *resultobj = 0;
5726 wxPoint *arg1 = (wxPoint *) 0 ;
5727 int arg2 ;
5728 void *argp1 = 0 ;
5729 int res1 = 0 ;
5730 int val2 ;
5731 int ecode2 = 0 ;
5732 PyObject *swig_obj[2] ;
5733
5734 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxPoint * >(argp1);
5740 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5741 if (!SWIG_IsOK(ecode2)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5743 }
5744 arg2 = static_cast< int >(val2);
5745 if (arg1) (arg1)->x = arg2;
5746
5747 resultobj = SWIG_Py_Void();
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5755 PyObject *resultobj = 0;
5756 wxPoint *arg1 = (wxPoint *) 0 ;
5757 int result;
5758 void *argp1 = 0 ;
5759 int res1 = 0 ;
5760 PyObject *swig_obj[1] ;
5761
5762 if (!args) SWIG_fail;
5763 swig_obj[0] = args;
5764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5765 if (!SWIG_IsOK(res1)) {
5766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5767 }
5768 arg1 = reinterpret_cast< wxPoint * >(argp1);
5769 result = (int) ((arg1)->x);
5770 resultobj = SWIG_From_int(static_cast< int >(result));
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5778 PyObject *resultobj = 0;
5779 wxPoint *arg1 = (wxPoint *) 0 ;
5780 int arg2 ;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 int val2 ;
5784 int ecode2 = 0 ;
5785 PyObject *swig_obj[2] ;
5786
5787 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5789 if (!SWIG_IsOK(res1)) {
5790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5791 }
5792 arg1 = reinterpret_cast< wxPoint * >(argp1);
5793 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5794 if (!SWIG_IsOK(ecode2)) {
5795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5796 }
5797 arg2 = static_cast< int >(val2);
5798 if (arg1) (arg1)->y = arg2;
5799
5800 resultobj = SWIG_Py_Void();
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5808 PyObject *resultobj = 0;
5809 wxPoint *arg1 = (wxPoint *) 0 ;
5810 int result;
5811 void *argp1 = 0 ;
5812 int res1 = 0 ;
5813 PyObject *swig_obj[1] ;
5814
5815 if (!args) SWIG_fail;
5816 swig_obj[0] = args;
5817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5818 if (!SWIG_IsOK(res1)) {
5819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5820 }
5821 arg1 = reinterpret_cast< wxPoint * >(argp1);
5822 result = (int) ((arg1)->y);
5823 resultobj = SWIG_From_int(static_cast< int >(result));
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = 0;
5832 int arg1 = (int) 0 ;
5833 int arg2 = (int) 0 ;
5834 wxPoint *result = 0 ;
5835 int val1 ;
5836 int ecode1 = 0 ;
5837 int val2 ;
5838 int ecode2 = 0 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "x",(char *) "y", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5846 if (obj0) {
5847 ecode1 = SWIG_AsVal_int(obj0, &val1);
5848 if (!SWIG_IsOK(ecode1)) {
5849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5850 }
5851 arg1 = static_cast< int >(val1);
5852 }
5853 if (obj1) {
5854 ecode2 = SWIG_AsVal_int(obj1, &val2);
5855 if (!SWIG_IsOK(ecode2)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5857 }
5858 arg2 = static_cast< int >(val2);
5859 }
5860 {
5861 result = (wxPoint *)new wxPoint(arg1,arg2);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5872 PyObject *resultobj = 0;
5873 wxPoint *arg1 = (wxPoint *) 0 ;
5874 void *argp1 = 0 ;
5875 int res1 = 0 ;
5876 PyObject *swig_obj[1] ;
5877
5878 if (!args) SWIG_fail;
5879 swig_obj[0] = args;
5880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 delete arg1;
5887
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 resultobj = SWIG_Py_Void();
5891 return resultobj;
5892 fail:
5893 return NULL;
5894 }
5895
5896
5897 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5898 PyObject *resultobj = 0;
5899 wxPoint *arg1 = (wxPoint *) 0 ;
5900 PyObject *arg2 = (PyObject *) 0 ;
5901 bool result;
5902 void *argp1 = 0 ;
5903 int res1 = 0 ;
5904 PyObject * obj0 = 0 ;
5905 PyObject * obj1 = 0 ;
5906 char * kwnames[] = {
5907 (char *) "self",(char *) "other", NULL
5908 };
5909
5910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5912 if (!SWIG_IsOK(res1)) {
5913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5914 }
5915 arg1 = reinterpret_cast< wxPoint * >(argp1);
5916 arg2 = obj1;
5917 {
5918 result = (bool)wxPoint___eq__(arg1,arg2);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5923 }
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj = 0;
5932 wxPoint *arg1 = (wxPoint *) 0 ;
5933 PyObject *arg2 = (PyObject *) 0 ;
5934 bool result;
5935 void *argp1 = 0 ;
5936 int res1 = 0 ;
5937 PyObject * obj0 = 0 ;
5938 PyObject * obj1 = 0 ;
5939 char * kwnames[] = {
5940 (char *) "self",(char *) "other", NULL
5941 };
5942
5943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5945 if (!SWIG_IsOK(res1)) {
5946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5947 }
5948 arg1 = reinterpret_cast< wxPoint * >(argp1);
5949 arg2 = obj1;
5950 {
5951 result = (bool)wxPoint___ne__(arg1,arg2);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj = 0;
5965 wxPoint *arg1 = (wxPoint *) 0 ;
5966 wxPoint *arg2 = 0 ;
5967 wxPoint result;
5968 void *argp1 = 0 ;
5969 int res1 = 0 ;
5970 wxPoint temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char * kwnames[] = {
5974 (char *) "self",(char *) "pt", NULL
5975 };
5976
5977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5979 if (!SWIG_IsOK(res1)) {
5980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5981 }
5982 arg1 = reinterpret_cast< wxPoint * >(argp1);
5983 {
5984 arg2 = &temp2;
5985 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5986 }
5987 {
5988 result = (arg1)->operator +((wxPoint const &)*arg2);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj = 0;
6000 wxPoint *arg1 = (wxPoint *) 0 ;
6001 wxPoint *arg2 = 0 ;
6002 wxPoint result;
6003 void *argp1 = 0 ;
6004 int res1 = 0 ;
6005 wxPoint temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char * kwnames[] = {
6009 (char *) "self",(char *) "pt", NULL
6010 };
6011
6012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6014 if (!SWIG_IsOK(res1)) {
6015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6016 }
6017 arg1 = reinterpret_cast< wxPoint * >(argp1);
6018 {
6019 arg2 = &temp2;
6020 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6021 }
6022 {
6023 result = (arg1)->operator -((wxPoint const &)*arg2);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj = 0;
6035 wxPoint *arg1 = (wxPoint *) 0 ;
6036 wxPoint *arg2 = 0 ;
6037 wxPoint *result = 0 ;
6038 void *argp1 = 0 ;
6039 int res1 = 0 ;
6040 wxPoint temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char * kwnames[] = {
6044 (char *) "self",(char *) "pt", NULL
6045 };
6046
6047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6049 if (!SWIG_IsOK(res1)) {
6050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6051 }
6052 arg1 = reinterpret_cast< wxPoint * >(argp1);
6053 {
6054 arg2 = &temp2;
6055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 {
6059 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6060 result = (wxPoint *) &_result_ref;
6061 }
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 wxPoint *arg1 = (wxPoint *) 0 ;
6074 wxPoint *arg2 = 0 ;
6075 wxPoint *result = 0 ;
6076 void *argp1 = 0 ;
6077 int res1 = 0 ;
6078 wxPoint temp2 ;
6079 PyObject * obj0 = 0 ;
6080 PyObject * obj1 = 0 ;
6081 char * kwnames[] = {
6082 (char *) "self",(char *) "pt", NULL
6083 };
6084
6085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6087 if (!SWIG_IsOK(res1)) {
6088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6089 }
6090 arg1 = reinterpret_cast< wxPoint * >(argp1);
6091 {
6092 arg2 = &temp2;
6093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6094 }
6095 {
6096 {
6097 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6098 result = (wxPoint *) &_result_ref;
6099 }
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = 0;
6111 wxPoint *arg1 = (wxPoint *) 0 ;
6112 long arg2 ;
6113 long arg3 ;
6114 void *argp1 = 0 ;
6115 int res1 = 0 ;
6116 long val2 ;
6117 int ecode2 = 0 ;
6118 long val3 ;
6119 int ecode3 = 0 ;
6120 PyObject * obj0 = 0 ;
6121 PyObject * obj1 = 0 ;
6122 PyObject * obj2 = 0 ;
6123 char * kwnames[] = {
6124 (char *) "self",(char *) "x",(char *) "y", NULL
6125 };
6126
6127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6129 if (!SWIG_IsOK(res1)) {
6130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6131 }
6132 arg1 = reinterpret_cast< wxPoint * >(argp1);
6133 ecode2 = SWIG_AsVal_long(obj1, &val2);
6134 if (!SWIG_IsOK(ecode2)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6136 }
6137 arg2 = static_cast< long >(val2);
6138 ecode3 = SWIG_AsVal_long(obj2, &val3);
6139 if (!SWIG_IsOK(ecode3)) {
6140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6141 }
6142 arg3 = static_cast< long >(val3);
6143 {
6144 wxPoint_Set(arg1,arg2,arg3);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_Py_Void();
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *resultobj = 0;
6156 wxPoint *arg1 = (wxPoint *) 0 ;
6157 PyObject *result = 0 ;
6158 void *argp1 = 0 ;
6159 int res1 = 0 ;
6160 PyObject *swig_obj[1] ;
6161
6162 if (!args) SWIG_fail;
6163 swig_obj[0] = args;
6164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6165 if (!SWIG_IsOK(res1)) {
6166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6167 }
6168 arg1 = reinterpret_cast< wxPoint * >(argp1);
6169 {
6170 result = (PyObject *)wxPoint_Get(arg1);
6171 if (PyErr_Occurred()) SWIG_fail;
6172 }
6173 resultobj = result;
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6181 PyObject *obj;
6182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6183 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6184 return SWIG_Py_Void();
6185 }
6186
6187 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6188 return SWIG_Python_InitShadowInstance(args);
6189 }
6190
6191 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj = 0;
6193 int arg1 = (int) 0 ;
6194 int arg2 = (int) 0 ;
6195 int arg3 = (int) 0 ;
6196 int arg4 = (int) 0 ;
6197 wxRect *result = 0 ;
6198 int val1 ;
6199 int ecode1 = 0 ;
6200 int val2 ;
6201 int ecode2 = 0 ;
6202 int val3 ;
6203 int ecode3 = 0 ;
6204 int val4 ;
6205 int ecode4 = 0 ;
6206 PyObject * obj0 = 0 ;
6207 PyObject * obj1 = 0 ;
6208 PyObject * obj2 = 0 ;
6209 PyObject * obj3 = 0 ;
6210 char * kwnames[] = {
6211 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6212 };
6213
6214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6215 if (obj0) {
6216 ecode1 = SWIG_AsVal_int(obj0, &val1);
6217 if (!SWIG_IsOK(ecode1)) {
6218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6219 }
6220 arg1 = static_cast< int >(val1);
6221 }
6222 if (obj1) {
6223 ecode2 = SWIG_AsVal_int(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6226 }
6227 arg2 = static_cast< int >(val2);
6228 }
6229 if (obj2) {
6230 ecode3 = SWIG_AsVal_int(obj2, &val3);
6231 if (!SWIG_IsOK(ecode3)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6233 }
6234 arg3 = static_cast< int >(val3);
6235 }
6236 if (obj3) {
6237 ecode4 = SWIG_AsVal_int(obj3, &val4);
6238 if (!SWIG_IsOK(ecode4)) {
6239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6240 }
6241 arg4 = static_cast< int >(val4);
6242 }
6243 {
6244 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6245 if (PyErr_Occurred()) SWIG_fail;
6246 }
6247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6255 PyObject *resultobj = 0;
6256 wxPoint *arg1 = 0 ;
6257 wxPoint *arg2 = 0 ;
6258 wxRect *result = 0 ;
6259 wxPoint temp1 ;
6260 wxPoint temp2 ;
6261 PyObject * obj0 = 0 ;
6262 PyObject * obj1 = 0 ;
6263 char * kwnames[] = {
6264 (char *) "topLeft",(char *) "bottomRight", NULL
6265 };
6266
6267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6268 {
6269 arg1 = &temp1;
6270 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6271 }
6272 {
6273 arg2 = &temp2;
6274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6275 }
6276 {
6277 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj = 0;
6289 wxPoint *arg1 = 0 ;
6290 wxSize *arg2 = 0 ;
6291 wxRect *result = 0 ;
6292 wxPoint temp1 ;
6293 wxSize temp2 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char * kwnames[] = {
6297 (char *) "pos",(char *) "size", NULL
6298 };
6299
6300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6301 {
6302 arg1 = &temp1;
6303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6304 }
6305 {
6306 arg2 = &temp2;
6307 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6308 }
6309 {
6310 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6311 if (PyErr_Occurred()) SWIG_fail;
6312 }
6313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj = 0;
6322 wxSize *arg1 = 0 ;
6323 wxRect *result = 0 ;
6324 wxSize temp1 ;
6325 PyObject * obj0 = 0 ;
6326 char * kwnames[] = {
6327 (char *) "size", NULL
6328 };
6329
6330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6331 {
6332 arg1 = &temp1;
6333 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6334 }
6335 {
6336 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 delete arg1;
6362
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_Py_Void();
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int result;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 PyObject *swig_obj[1] ;
6379
6380 if (!args) SWIG_fail;
6381 swig_obj[0] = args;
6382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6385 }
6386 arg1 = reinterpret_cast< wxRect * >(argp1);
6387 {
6388 result = (int)((wxRect const *)arg1)->GetX();
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = SWIG_From_int(static_cast< int >(result));
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6399 PyObject *resultobj = 0;
6400 wxRect *arg1 = (wxRect *) 0 ;
6401 int arg2 ;
6402 void *argp1 = 0 ;
6403 int res1 = 0 ;
6404 int val2 ;
6405 int ecode2 = 0 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "self",(char *) "x", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6414 if (!SWIG_IsOK(res1)) {
6415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6416 }
6417 arg1 = reinterpret_cast< wxRect * >(argp1);
6418 ecode2 = SWIG_AsVal_int(obj1, &val2);
6419 if (!SWIG_IsOK(ecode2)) {
6420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6421 }
6422 arg2 = static_cast< int >(val2);
6423 {
6424 (arg1)->SetX(arg2);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = SWIG_Py_Void();
6428 return resultobj;
6429 fail:
6430 return NULL;
6431 }
6432
6433
6434 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6435 PyObject *resultobj = 0;
6436 wxRect *arg1 = (wxRect *) 0 ;
6437 int result;
6438 void *argp1 = 0 ;
6439 int res1 = 0 ;
6440 PyObject *swig_obj[1] ;
6441
6442 if (!args) SWIG_fail;
6443 swig_obj[0] = args;
6444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6445 if (!SWIG_IsOK(res1)) {
6446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6447 }
6448 arg1 = reinterpret_cast< wxRect * >(argp1);
6449 {
6450 result = (int)(arg1)->GetY();
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_From_int(static_cast< int >(result));
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int arg2 ;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 int val2 ;
6467 int ecode2 = 0 ;
6468 PyObject * obj0 = 0 ;
6469 PyObject * obj1 = 0 ;
6470 char * kwnames[] = {
6471 (char *) "self",(char *) "y", NULL
6472 };
6473
6474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6478 }
6479 arg1 = reinterpret_cast< wxRect * >(argp1);
6480 ecode2 = SWIG_AsVal_int(obj1, &val2);
6481 if (!SWIG_IsOK(ecode2)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6483 }
6484 arg2 = static_cast< int >(val2);
6485 {
6486 (arg1)->SetY(arg2);
6487 if (PyErr_Occurred()) SWIG_fail;
6488 }
6489 resultobj = SWIG_Py_Void();
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6497 PyObject *resultobj = 0;
6498 wxRect *arg1 = (wxRect *) 0 ;
6499 int result;
6500 void *argp1 = 0 ;
6501 int res1 = 0 ;
6502 PyObject *swig_obj[1] ;
6503
6504 if (!args) SWIG_fail;
6505 swig_obj[0] = args;
6506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6509 }
6510 arg1 = reinterpret_cast< wxRect * >(argp1);
6511 {
6512 result = (int)((wxRect const *)arg1)->GetWidth();
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 resultobj = SWIG_From_int(static_cast< int >(result));
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6523 PyObject *resultobj = 0;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 int arg2 ;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 int val2 ;
6529 int ecode2 = 0 ;
6530 PyObject * obj0 = 0 ;
6531 PyObject * obj1 = 0 ;
6532 char * kwnames[] = {
6533 (char *) "self",(char *) "w", NULL
6534 };
6535
6536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 ecode2 = SWIG_AsVal_int(obj1, &val2);
6543 if (!SWIG_IsOK(ecode2)) {
6544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6545 }
6546 arg2 = static_cast< int >(val2);
6547 {
6548 (arg1)->SetWidth(arg2);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 resultobj = SWIG_Py_Void();
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6559 PyObject *resultobj = 0;
6560 wxRect *arg1 = (wxRect *) 0 ;
6561 int result;
6562 void *argp1 = 0 ;
6563 int res1 = 0 ;
6564 PyObject *swig_obj[1] ;
6565
6566 if (!args) SWIG_fail;
6567 swig_obj[0] = args;
6568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 result = (int)((wxRect const *)arg1)->GetHeight();
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj = 0;
6586 wxRect *arg1 = (wxRect *) 0 ;
6587 int arg2 ;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 int val2 ;
6591 int ecode2 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 char * kwnames[] = {
6595 (char *) "self",(char *) "h", NULL
6596 };
6597
6598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 ecode2 = SWIG_AsVal_int(obj1, &val2);
6605 if (!SWIG_IsOK(ecode2)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6607 }
6608 arg2 = static_cast< int >(val2);
6609 {
6610 (arg1)->SetHeight(arg2);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_Py_Void();
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6621 PyObject *resultobj = 0;
6622 wxRect *arg1 = (wxRect *) 0 ;
6623 wxPoint result;
6624 void *argp1 = 0 ;
6625 int res1 = 0 ;
6626 PyObject *swig_obj[1] ;
6627
6628 if (!args) SWIG_fail;
6629 swig_obj[0] = args;
6630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6631 if (!SWIG_IsOK(res1)) {
6632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6633 }
6634 arg1 = reinterpret_cast< wxRect * >(argp1);
6635 {
6636 result = ((wxRect const *)arg1)->GetPosition();
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj = 0;
6648 wxRect *arg1 = (wxRect *) 0 ;
6649 wxPoint *arg2 = 0 ;
6650 void *argp1 = 0 ;
6651 int res1 = 0 ;
6652 wxPoint temp2 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 char * kwnames[] = {
6656 (char *) "self",(char *) "p", NULL
6657 };
6658
6659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6661 if (!SWIG_IsOK(res1)) {
6662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6663 }
6664 arg1 = reinterpret_cast< wxRect * >(argp1);
6665 {
6666 arg2 = &temp2;
6667 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6668 }
6669 {
6670 (arg1)->SetPosition((wxPoint const &)*arg2);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 resultobj = SWIG_Py_Void();
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxRect *arg1 = (wxRect *) 0 ;
6683 wxSize result;
6684 void *argp1 = 0 ;
6685 int res1 = 0 ;
6686 PyObject *swig_obj[1] ;
6687
6688 if (!args) SWIG_fail;
6689 swig_obj[0] = args;
6690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6691 if (!SWIG_IsOK(res1)) {
6692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6693 }
6694 arg1 = reinterpret_cast< wxRect * >(argp1);
6695 {
6696 result = ((wxRect const *)arg1)->GetSize();
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj = 0;
6708 wxRect *arg1 = (wxRect *) 0 ;
6709 wxSize *arg2 = 0 ;
6710 void *argp1 = 0 ;
6711 int res1 = 0 ;
6712 wxSize temp2 ;
6713 PyObject * obj0 = 0 ;
6714 PyObject * obj1 = 0 ;
6715 char * kwnames[] = {
6716 (char *) "self",(char *) "s", NULL
6717 };
6718
6719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6721 if (!SWIG_IsOK(res1)) {
6722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6723 }
6724 arg1 = reinterpret_cast< wxRect * >(argp1);
6725 {
6726 arg2 = &temp2;
6727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6728 }
6729 {
6730 (arg1)->SetSize((wxSize const &)*arg2);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 resultobj = SWIG_Py_Void();
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6741 PyObject *resultobj = 0;
6742 wxRect *arg1 = (wxRect *) 0 ;
6743 bool result;
6744 void *argp1 = 0 ;
6745 int res1 = 0 ;
6746 PyObject *swig_obj[1] ;
6747
6748 if (!args) SWIG_fail;
6749 swig_obj[0] = args;
6750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6751 if (!SWIG_IsOK(res1)) {
6752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6753 }
6754 arg1 = reinterpret_cast< wxRect * >(argp1);
6755 {
6756 result = (bool)((wxRect const *)arg1)->IsEmpty();
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 {
6760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6761 }
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6769 PyObject *resultobj = 0;
6770 wxRect *arg1 = (wxRect *) 0 ;
6771 wxPoint result;
6772 void *argp1 = 0 ;
6773 int res1 = 0 ;
6774 PyObject *swig_obj[1] ;
6775
6776 if (!args) SWIG_fail;
6777 swig_obj[0] = args;
6778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6779 if (!SWIG_IsOK(res1)) {
6780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6781 }
6782 arg1 = reinterpret_cast< wxRect * >(argp1);
6783 {
6784 result = ((wxRect const *)arg1)->GetTopLeft();
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj = 0;
6796 wxRect *arg1 = (wxRect *) 0 ;
6797 wxPoint *arg2 = 0 ;
6798 void *argp1 = 0 ;
6799 int res1 = 0 ;
6800 wxPoint temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char * kwnames[] = {
6804 (char *) "self",(char *) "p", NULL
6805 };
6806
6807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6809 if (!SWIG_IsOK(res1)) {
6810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6811 }
6812 arg1 = reinterpret_cast< wxRect * >(argp1);
6813 {
6814 arg2 = &temp2;
6815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6816 }
6817 {
6818 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 wxPoint result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 result = ((wxRect const *)arg1)->GetBottomRight();
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj = 0;
6856 wxRect *arg1 = (wxRect *) 0 ;
6857 wxPoint *arg2 = 0 ;
6858 void *argp1 = 0 ;
6859 int res1 = 0 ;
6860 wxPoint temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char * kwnames[] = {
6864 (char *) "self",(char *) "p", NULL
6865 };
6866
6867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 {
6874 arg2 = &temp2;
6875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6876 }
6877 {
6878 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_Py_Void();
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6889 PyObject *resultobj = 0;
6890 wxRect *arg1 = (wxRect *) 0 ;
6891 wxPoint result;
6892 void *argp1 = 0 ;
6893 int res1 = 0 ;
6894 PyObject *swig_obj[1] ;
6895
6896 if (!args) SWIG_fail;
6897 swig_obj[0] = args;
6898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 {
6904 result = ((wxRect const *)arg1)->GetTopRight();
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj = 0;
6916 wxRect *arg1 = (wxRect *) 0 ;
6917 wxPoint *arg2 = 0 ;
6918 void *argp1 = 0 ;
6919 int res1 = 0 ;
6920 wxPoint temp2 ;
6921 PyObject * obj0 = 0 ;
6922 PyObject * obj1 = 0 ;
6923 char * kwnames[] = {
6924 (char *) "self",(char *) "p", NULL
6925 };
6926
6927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6929 if (!SWIG_IsOK(res1)) {
6930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6931 }
6932 arg1 = reinterpret_cast< wxRect * >(argp1);
6933 {
6934 arg2 = &temp2;
6935 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6936 }
6937 {
6938 (arg1)->SetTopRight((wxPoint const &)*arg2);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 resultobj = SWIG_Py_Void();
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6949 PyObject *resultobj = 0;
6950 wxRect *arg1 = (wxRect *) 0 ;
6951 wxPoint result;
6952 void *argp1 = 0 ;
6953 int res1 = 0 ;
6954 PyObject *swig_obj[1] ;
6955
6956 if (!args) SWIG_fail;
6957 swig_obj[0] = args;
6958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 {
6964 result = ((wxRect const *)arg1)->GetBottomLeft();
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxRect *arg1 = (wxRect *) 0 ;
6977 wxPoint *arg2 = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 wxPoint temp2 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char * kwnames[] = {
6984 (char *) "self",(char *) "p", NULL
6985 };
6986
6987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 {
6994 arg2 = &temp2;
6995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6996 }
6997 {
6998 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_Py_Void();
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 wxRect *arg1 = (wxRect *) 0 ;
7011 int result;
7012 void *argp1 = 0 ;
7013 int res1 = 0 ;
7014 PyObject *swig_obj[1] ;
7015
7016 if (!args) SWIG_fail;
7017 swig_obj[0] = args;
7018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7019 if (!SWIG_IsOK(res1)) {
7020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7021 }
7022 arg1 = reinterpret_cast< wxRect * >(argp1);
7023 {
7024 result = (int)((wxRect const *)arg1)->GetLeft();
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_From_int(static_cast< int >(result));
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int result;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 PyObject *swig_obj[1] ;
7041
7042 if (!args) SWIG_fail;
7043 swig_obj[0] = args;
7044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 {
7050 result = (int)((wxRect const *)arg1)->GetTop();
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_From_int(static_cast< int >(result));
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7061 PyObject *resultobj = 0;
7062 wxRect *arg1 = (wxRect *) 0 ;
7063 int result;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 PyObject *swig_obj[1] ;
7067
7068 if (!args) SWIG_fail;
7069 swig_obj[0] = args;
7070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7071 if (!SWIG_IsOK(res1)) {
7072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7073 }
7074 arg1 = reinterpret_cast< wxRect * >(argp1);
7075 {
7076 result = (int)((wxRect const *)arg1)->GetBottom();
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_From_int(static_cast< int >(result));
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7087 PyObject *resultobj = 0;
7088 wxRect *arg1 = (wxRect *) 0 ;
7089 int result;
7090 void *argp1 = 0 ;
7091 int res1 = 0 ;
7092 PyObject *swig_obj[1] ;
7093
7094 if (!args) SWIG_fail;
7095 swig_obj[0] = args;
7096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 {
7102 result = (int)((wxRect const *)arg1)->GetRight();
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_From_int(static_cast< int >(result));
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj = 0;
7114 wxRect *arg1 = (wxRect *) 0 ;
7115 int arg2 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 int val2 ;
7119 int ecode2 = 0 ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "self",(char *) "left", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7128 if (!SWIG_IsOK(res1)) {
7129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7130 }
7131 arg1 = reinterpret_cast< wxRect * >(argp1);
7132 ecode2 = SWIG_AsVal_int(obj1, &val2);
7133 if (!SWIG_IsOK(ecode2)) {
7134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7135 }
7136 arg2 = static_cast< int >(val2);
7137 {
7138 (arg1)->SetLeft(arg2);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_Py_Void();
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 int arg2 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 int val2 ;
7155 int ecode2 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "right", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 {
7174 (arg1)->SetRight(arg2);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_Py_Void();
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxRect *arg1 = (wxRect *) 0 ;
7187 int arg2 ;
7188 void *argp1 = 0 ;
7189 int res1 = 0 ;
7190 int val2 ;
7191 int ecode2 = 0 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "self",(char *) "top", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7202 }
7203 arg1 = reinterpret_cast< wxRect * >(argp1);
7204 ecode2 = SWIG_AsVal_int(obj1, &val2);
7205 if (!SWIG_IsOK(ecode2)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7207 }
7208 arg2 = static_cast< int >(val2);
7209 {
7210 (arg1)->SetTop(arg2);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_Py_Void();
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxRect *arg1 = (wxRect *) 0 ;
7223 int arg2 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 int val2 ;
7227 int ecode2 = 0 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "bottom", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 ecode2 = SWIG_AsVal_int(obj1, &val2);
7241 if (!SWIG_IsOK(ecode2)) {
7242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7243 }
7244 arg2 = static_cast< int >(val2);
7245 {
7246 (arg1)->SetBottom(arg2);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 resultobj = SWIG_Py_Void();
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxRect *arg1 = (wxRect *) 0 ;
7259 int arg2 ;
7260 int arg3 ;
7261 wxRect *result = 0 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 int val2 ;
7265 int ecode2 = 0 ;
7266 int val3 ;
7267 int ecode3 = 0 ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 PyObject * obj2 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "dx",(char *) "dy", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 ecode2 = SWIG_AsVal_int(obj1, &val2);
7282 if (!SWIG_IsOK(ecode2)) {
7283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7284 }
7285 arg2 = static_cast< int >(val2);
7286 ecode3 = SWIG_AsVal_int(obj2, &val3);
7287 if (!SWIG_IsOK(ecode3)) {
7288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7289 }
7290 arg3 = static_cast< int >(val3);
7291 {
7292 {
7293 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7294 result = (wxRect *) &_result_ref;
7295 }
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj = 0;
7307 wxRect *arg1 = (wxRect *) 0 ;
7308 int arg2 ;
7309 int arg3 ;
7310 wxRect *result = 0 ;
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_Deflate",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_Deflate" "', 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_Deflate" "', 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_Deflate" "', expected argument " "3"" of type '" "int""'");
7338 }
7339 arg3 = static_cast< int >(val3);
7340 {
7341 {
7342 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7343 result = (wxRect *) &_result_ref;
7344 }
7345 if (PyErr_Occurred()) SWIG_fail;
7346 }
7347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7348 return resultobj;
7349 fail:
7350 return NULL;
7351 }
7352
7353
7354 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7355 PyObject *resultobj = 0;
7356 wxRect *arg1 = (wxRect *) 0 ;
7357 int arg2 ;
7358 int arg3 ;
7359 void *argp1 = 0 ;
7360 int res1 = 0 ;
7361 int val2 ;
7362 int ecode2 = 0 ;
7363 int val3 ;
7364 int ecode3 = 0 ;
7365 PyObject * obj0 = 0 ;
7366 PyObject * obj1 = 0 ;
7367 PyObject * obj2 = 0 ;
7368 char * kwnames[] = {
7369 (char *) "self",(char *) "dx",(char *) "dy", NULL
7370 };
7371
7372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7374 if (!SWIG_IsOK(res1)) {
7375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7376 }
7377 arg1 = reinterpret_cast< wxRect * >(argp1);
7378 ecode2 = SWIG_AsVal_int(obj1, &val2);
7379 if (!SWIG_IsOK(ecode2)) {
7380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7381 }
7382 arg2 = static_cast< int >(val2);
7383 ecode3 = SWIG_AsVal_int(obj2, &val3);
7384 if (!SWIG_IsOK(ecode3)) {
7385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7386 }
7387 arg3 = static_cast< int >(val3);
7388 {
7389 (arg1)->Offset(arg2,arg3);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_Py_Void();
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxRect *arg1 = (wxRect *) 0 ;
7402 wxPoint *arg2 = 0 ;
7403 void *argp1 = 0 ;
7404 int res1 = 0 ;
7405 wxPoint temp2 ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 char * kwnames[] = {
7409 (char *) "self",(char *) "pt", NULL
7410 };
7411
7412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7416 }
7417 arg1 = reinterpret_cast< wxRect * >(argp1);
7418 {
7419 arg2 = &temp2;
7420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7421 }
7422 {
7423 (arg1)->Offset((wxPoint const &)*arg2);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 resultobj = SWIG_Py_Void();
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj = 0;
7435 wxRect *arg1 = (wxRect *) 0 ;
7436 wxRect *arg2 = 0 ;
7437 wxRect result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 wxRect temp2 ;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 char * kwnames[] = {
7444 (char *) "self",(char *) "rect", NULL
7445 };
7446
7447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7449 if (!SWIG_IsOK(res1)) {
7450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7451 }
7452 arg1 = reinterpret_cast< wxRect * >(argp1);
7453 {
7454 arg2 = &temp2;
7455 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7456 }
7457 {
7458 result = (arg1)->Intersect((wxRect const &)*arg2);
7459 if (PyErr_Occurred()) SWIG_fail;
7460 }
7461 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7462 return resultobj;
7463 fail:
7464 return NULL;
7465 }
7466
7467
7468 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7469 PyObject *resultobj = 0;
7470 wxRect *arg1 = (wxRect *) 0 ;
7471 wxRect *arg2 = 0 ;
7472 wxRect result;
7473 void *argp1 = 0 ;
7474 int res1 = 0 ;
7475 wxRect temp2 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 char * kwnames[] = {
7479 (char *) "self",(char *) "rect", NULL
7480 };
7481
7482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7486 }
7487 arg1 = reinterpret_cast< wxRect * >(argp1);
7488 {
7489 arg2 = &temp2;
7490 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7491 }
7492 {
7493 result = (arg1)->Union((wxRect const &)*arg2);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj = 0;
7505 wxRect *arg1 = (wxRect *) 0 ;
7506 wxRect *arg2 = 0 ;
7507 wxRect result;
7508 void *argp1 = 0 ;
7509 int res1 = 0 ;
7510 wxRect temp2 ;
7511 PyObject * obj0 = 0 ;
7512 PyObject * obj1 = 0 ;
7513 char * kwnames[] = {
7514 (char *) "self",(char *) "rect", NULL
7515 };
7516
7517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7519 if (!SWIG_IsOK(res1)) {
7520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7521 }
7522 arg1 = reinterpret_cast< wxRect * >(argp1);
7523 {
7524 arg2 = &temp2;
7525 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7526 }
7527 {
7528 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj = 0;
7540 wxRect *arg1 = (wxRect *) 0 ;
7541 wxRect *arg2 = 0 ;
7542 wxRect *result = 0 ;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 wxRect temp2 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char * kwnames[] = {
7549 (char *) "self",(char *) "rect", NULL
7550 };
7551
7552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 {
7559 arg2 = &temp2;
7560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7561 }
7562 {
7563 {
7564 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7565 result = (wxRect *) &_result_ref;
7566 }
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7577 PyObject *resultobj = 0;
7578 wxRect *arg1 = (wxRect *) 0 ;
7579 PyObject *arg2 = (PyObject *) 0 ;
7580 bool result;
7581 void *argp1 = 0 ;
7582 int res1 = 0 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char * kwnames[] = {
7586 (char *) "self",(char *) "other", NULL
7587 };
7588
7589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7593 }
7594 arg1 = reinterpret_cast< wxRect * >(argp1);
7595 arg2 = obj1;
7596 {
7597 result = (bool)wxRect___eq__(arg1,arg2);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 {
7601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7602 }
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj = 0;
7611 wxRect *arg1 = (wxRect *) 0 ;
7612 PyObject *arg2 = (PyObject *) 0 ;
7613 bool result;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 PyObject * obj0 = 0 ;
7617 PyObject * obj1 = 0 ;
7618 char * kwnames[] = {
7619 (char *) "self",(char *) "other", NULL
7620 };
7621
7622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7624 if (!SWIG_IsOK(res1)) {
7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7626 }
7627 arg1 = reinterpret_cast< wxRect * >(argp1);
7628 arg2 = obj1;
7629 {
7630 result = (bool)wxRect___ne__(arg1,arg2);
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_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = 0;
7644 wxRect *arg1 = (wxRect *) 0 ;
7645 int arg2 ;
7646 int arg3 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 int val2 ;
7651 int ecode2 = 0 ;
7652 int val3 ;
7653 int ecode3 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 PyObject * obj2 = 0 ;
7657 char * kwnames[] = {
7658 (char *) "self",(char *) "x",(char *) "y", NULL
7659 };
7660
7661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(obj1, &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 ecode3 = SWIG_AsVal_int(obj2, &val3);
7673 if (!SWIG_IsOK(ecode3)) {
7674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7675 }
7676 arg3 = static_cast< int >(val3);
7677 {
7678 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj = 0;
7692 wxRect *arg1 = (wxRect *) 0 ;
7693 wxPoint *arg2 = 0 ;
7694 bool result;
7695 void *argp1 = 0 ;
7696 int res1 = 0 ;
7697 wxPoint temp2 ;
7698 PyObject * obj0 = 0 ;
7699 PyObject * obj1 = 0 ;
7700 char * kwnames[] = {
7701 (char *) "self",(char *) "pt", NULL
7702 };
7703
7704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7706 if (!SWIG_IsOK(res1)) {
7707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7708 }
7709 arg1 = reinterpret_cast< wxRect * >(argp1);
7710 {
7711 arg2 = &temp2;
7712 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7713 }
7714 {
7715 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7716 if (PyErr_Occurred()) SWIG_fail;
7717 }
7718 {
7719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7720 }
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj = 0;
7729 wxRect *arg1 = (wxRect *) 0 ;
7730 wxRect *arg2 = 0 ;
7731 bool result;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 wxRect temp2 ;
7735 PyObject * obj0 = 0 ;
7736 PyObject * obj1 = 0 ;
7737 char * kwnames[] = {
7738 (char *) "self",(char *) "rect", NULL
7739 };
7740
7741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7743 if (!SWIG_IsOK(res1)) {
7744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7745 }
7746 arg1 = reinterpret_cast< wxRect * >(argp1);
7747 {
7748 arg2 = &temp2;
7749 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7750 }
7751 {
7752 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7753 if (PyErr_Occurred()) SWIG_fail;
7754 }
7755 {
7756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7757 }
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj = 0;
7766 wxRect *arg1 = (wxRect *) 0 ;
7767 wxRect *arg2 = 0 ;
7768 bool result;
7769 void *argp1 = 0 ;
7770 int res1 = 0 ;
7771 wxRect temp2 ;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 char * kwnames[] = {
7775 (char *) "self",(char *) "rect", NULL
7776 };
7777
7778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7780 if (!SWIG_IsOK(res1)) {
7781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7782 }
7783 arg1 = reinterpret_cast< wxRect * >(argp1);
7784 {
7785 arg2 = &temp2;
7786 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7787 }
7788 {
7789 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7790 if (PyErr_Occurred()) SWIG_fail;
7791 }
7792 {
7793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7794 }
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj = 0;
7803 wxRect *arg1 = (wxRect *) 0 ;
7804 wxRect *arg2 = 0 ;
7805 int arg3 = (int) wxBOTH ;
7806 wxRect result;
7807 void *argp1 = 0 ;
7808 int res1 = 0 ;
7809 wxRect temp2 ;
7810 int val3 ;
7811 int ecode3 = 0 ;
7812 PyObject * obj0 = 0 ;
7813 PyObject * obj1 = 0 ;
7814 PyObject * obj2 = 0 ;
7815 char * kwnames[] = {
7816 (char *) "self",(char *) "r",(char *) "dir", NULL
7817 };
7818
7819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 {
7826 arg2 = &temp2;
7827 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7828 }
7829 if (obj2) {
7830 ecode3 = SWIG_AsVal_int(obj2, &val3);
7831 if (!SWIG_IsOK(ecode3)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7833 }
7834 arg3 = static_cast< int >(val3);
7835 }
7836 {
7837 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 PyObject *resultobj = 0;
7849 wxRect *arg1 = (wxRect *) 0 ;
7850 int arg2 ;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 int val2 ;
7854 int ecode2 = 0 ;
7855 PyObject *swig_obj[2] ;
7856
7857 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7861 }
7862 arg1 = reinterpret_cast< wxRect * >(argp1);
7863 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7864 if (!SWIG_IsOK(ecode2)) {
7865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7866 }
7867 arg2 = static_cast< int >(val2);
7868 if (arg1) (arg1)->x = arg2;
7869
7870 resultobj = SWIG_Py_Void();
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxRect *arg1 = (wxRect *) 0 ;
7880 int result;
7881 void *argp1 = 0 ;
7882 int res1 = 0 ;
7883 PyObject *swig_obj[1] ;
7884
7885 if (!args) SWIG_fail;
7886 swig_obj[0] = args;
7887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7890 }
7891 arg1 = reinterpret_cast< wxRect * >(argp1);
7892 result = (int) ((arg1)->x);
7893 resultobj = SWIG_From_int(static_cast< int >(result));
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901 PyObject *resultobj = 0;
7902 wxRect *arg1 = (wxRect *) 0 ;
7903 int arg2 ;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 int val2 ;
7907 int ecode2 = 0 ;
7908 PyObject *swig_obj[2] ;
7909
7910 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7912 if (!SWIG_IsOK(res1)) {
7913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7914 }
7915 arg1 = reinterpret_cast< wxRect * >(argp1);
7916 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7917 if (!SWIG_IsOK(ecode2)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7919 }
7920 arg2 = static_cast< int >(val2);
7921 if (arg1) (arg1)->y = arg2;
7922
7923 resultobj = SWIG_Py_Void();
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 PyObject *resultobj = 0;
7932 wxRect *arg1 = (wxRect *) 0 ;
7933 int result;
7934 void *argp1 = 0 ;
7935 int res1 = 0 ;
7936 PyObject *swig_obj[1] ;
7937
7938 if (!args) SWIG_fail;
7939 swig_obj[0] = args;
7940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7941 if (!SWIG_IsOK(res1)) {
7942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7943 }
7944 arg1 = reinterpret_cast< wxRect * >(argp1);
7945 result = (int) ((arg1)->y);
7946 resultobj = SWIG_From_int(static_cast< int >(result));
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7954 PyObject *resultobj = 0;
7955 wxRect *arg1 = (wxRect *) 0 ;
7956 int arg2 ;
7957 void *argp1 = 0 ;
7958 int res1 = 0 ;
7959 int val2 ;
7960 int ecode2 = 0 ;
7961 PyObject *swig_obj[2] ;
7962
7963 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7967 }
7968 arg1 = reinterpret_cast< wxRect * >(argp1);
7969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7970 if (!SWIG_IsOK(ecode2)) {
7971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7972 }
7973 arg2 = static_cast< int >(val2);
7974 if (arg1) (arg1)->width = arg2;
7975
7976 resultobj = SWIG_Py_Void();
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7984 PyObject *resultobj = 0;
7985 wxRect *arg1 = (wxRect *) 0 ;
7986 int result;
7987 void *argp1 = 0 ;
7988 int res1 = 0 ;
7989 PyObject *swig_obj[1] ;
7990
7991 if (!args) SWIG_fail;
7992 swig_obj[0] = args;
7993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7996 }
7997 arg1 = reinterpret_cast< wxRect * >(argp1);
7998 result = (int) ((arg1)->width);
7999 resultobj = SWIG_From_int(static_cast< int >(result));
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *resultobj = 0;
8008 wxRect *arg1 = (wxRect *) 0 ;
8009 int arg2 ;
8010 void *argp1 = 0 ;
8011 int res1 = 0 ;
8012 int val2 ;
8013 int ecode2 = 0 ;
8014 PyObject *swig_obj[2] ;
8015
8016 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8018 if (!SWIG_IsOK(res1)) {
8019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8020 }
8021 arg1 = reinterpret_cast< wxRect * >(argp1);
8022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8023 if (!SWIG_IsOK(ecode2)) {
8024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8025 }
8026 arg2 = static_cast< int >(val2);
8027 if (arg1) (arg1)->height = arg2;
8028
8029 resultobj = SWIG_Py_Void();
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8037 PyObject *resultobj = 0;
8038 wxRect *arg1 = (wxRect *) 0 ;
8039 int result;
8040 void *argp1 = 0 ;
8041 int res1 = 0 ;
8042 PyObject *swig_obj[1] ;
8043
8044 if (!args) SWIG_fail;
8045 swig_obj[0] = args;
8046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8047 if (!SWIG_IsOK(res1)) {
8048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8049 }
8050 arg1 = reinterpret_cast< wxRect * >(argp1);
8051 result = (int) ((arg1)->height);
8052 resultobj = SWIG_From_int(static_cast< int >(result));
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj = 0;
8061 wxRect *arg1 = (wxRect *) 0 ;
8062 int arg2 = (int) 0 ;
8063 int arg3 = (int) 0 ;
8064 int arg4 = (int) 0 ;
8065 int arg5 = (int) 0 ;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int val2 ;
8069 int ecode2 = 0 ;
8070 int val3 ;
8071 int ecode3 = 0 ;
8072 int val4 ;
8073 int ecode4 = 0 ;
8074 int val5 ;
8075 int ecode5 = 0 ;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 PyObject * obj2 = 0 ;
8079 PyObject * obj3 = 0 ;
8080 PyObject * obj4 = 0 ;
8081 char * kwnames[] = {
8082 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8083 };
8084
8085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8087 if (!SWIG_IsOK(res1)) {
8088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8089 }
8090 arg1 = reinterpret_cast< wxRect * >(argp1);
8091 if (obj1) {
8092 ecode2 = SWIG_AsVal_int(obj1, &val2);
8093 if (!SWIG_IsOK(ecode2)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8095 }
8096 arg2 = static_cast< int >(val2);
8097 }
8098 if (obj2) {
8099 ecode3 = SWIG_AsVal_int(obj2, &val3);
8100 if (!SWIG_IsOK(ecode3)) {
8101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8102 }
8103 arg3 = static_cast< int >(val3);
8104 }
8105 if (obj3) {
8106 ecode4 = SWIG_AsVal_int(obj3, &val4);
8107 if (!SWIG_IsOK(ecode4)) {
8108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8109 }
8110 arg4 = static_cast< int >(val4);
8111 }
8112 if (obj4) {
8113 ecode5 = SWIG_AsVal_int(obj4, &val5);
8114 if (!SWIG_IsOK(ecode5)) {
8115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8116 }
8117 arg5 = static_cast< int >(val5);
8118 }
8119 {
8120 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8121 if (PyErr_Occurred()) SWIG_fail;
8122 }
8123 resultobj = SWIG_Py_Void();
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 PyObject *result = 0 ;
8134 void *argp1 = 0 ;
8135 int res1 = 0 ;
8136 PyObject *swig_obj[1] ;
8137
8138 if (!args) SWIG_fail;
8139 swig_obj[0] = args;
8140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8141 if (!SWIG_IsOK(res1)) {
8142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8143 }
8144 arg1 = reinterpret_cast< wxRect * >(argp1);
8145 {
8146 result = (PyObject *)wxRect_Get(arg1);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = result;
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *obj;
8158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8159 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8160 return SWIG_Py_Void();
8161 }
8162
8163 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8164 return SWIG_Python_InitShadowInstance(args);
8165 }
8166
8167 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj = 0;
8169 wxRect *arg1 = (wxRect *) 0 ;
8170 wxRect *arg2 = (wxRect *) 0 ;
8171 PyObject *result = 0 ;
8172 void *argp1 = 0 ;
8173 int res1 = 0 ;
8174 void *argp2 = 0 ;
8175 int res2 = 0 ;
8176 PyObject * obj0 = 0 ;
8177 PyObject * obj1 = 0 ;
8178 char * kwnames[] = {
8179 (char *) "r1",(char *) "r2", NULL
8180 };
8181
8182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8184 if (!SWIG_IsOK(res1)) {
8185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8186 }
8187 arg1 = reinterpret_cast< wxRect * >(argp1);
8188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8189 if (!SWIG_IsOK(res2)) {
8190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8191 }
8192 arg2 = reinterpret_cast< wxRect * >(argp2);
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (PyObject *)wxIntersectRect(arg1,arg2);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = result;
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj = 0;
8209 double arg1 = (double) 0.0 ;
8210 double arg2 = (double) 0.0 ;
8211 wxPoint2D *result = 0 ;
8212 double val1 ;
8213 int ecode1 = 0 ;
8214 double val2 ;
8215 int ecode2 = 0 ;
8216 PyObject * obj0 = 0 ;
8217 PyObject * obj1 = 0 ;
8218 char * kwnames[] = {
8219 (char *) "x",(char *) "y", NULL
8220 };
8221
8222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8223 if (obj0) {
8224 ecode1 = SWIG_AsVal_double(obj0, &val1);
8225 if (!SWIG_IsOK(ecode1)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8227 }
8228 arg1 = static_cast< double >(val1);
8229 }
8230 if (obj1) {
8231 ecode2 = SWIG_AsVal_double(obj1, &val2);
8232 if (!SWIG_IsOK(ecode2)) {
8233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8234 }
8235 arg2 = static_cast< double >(val2);
8236 }
8237 {
8238 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = 0;
8250 wxPoint2D *arg1 = 0 ;
8251 wxPoint2D *result = 0 ;
8252 wxPoint2D temp1 ;
8253 PyObject * obj0 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "pt", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8259 {
8260 arg1 = &temp1;
8261 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8262 }
8263 {
8264 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxPoint *arg1 = 0 ;
8277 wxPoint2D *result = 0 ;
8278 wxPoint temp1 ;
8279 PyObject * obj0 = 0 ;
8280 char * kwnames[] = {
8281 (char *) "pt", NULL
8282 };
8283
8284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8285 {
8286 arg1 = &temp1;
8287 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8288 }
8289 {
8290 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 void *argp1 = 0 ;
8304 int res1 = 0 ;
8305 PyObject *swig_obj[1] ;
8306
8307 if (!args) SWIG_fail;
8308 swig_obj[0] = args;
8309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8310 if (!SWIG_IsOK(res1)) {
8311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8312 }
8313 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8314 {
8315 delete arg1;
8316
8317 if (PyErr_Occurred()) SWIG_fail;
8318 }
8319 resultobj = SWIG_Py_Void();
8320 return resultobj;
8321 fail:
8322 return NULL;
8323 }
8324
8325
8326 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8327 PyObject *resultobj = 0;
8328 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8329 int *arg2 = (int *) 0 ;
8330 int *arg3 = (int *) 0 ;
8331 void *argp1 = 0 ;
8332 int res1 = 0 ;
8333 int temp2 ;
8334 int res2 = SWIG_TMPOBJ ;
8335 int temp3 ;
8336 int res3 = SWIG_TMPOBJ ;
8337 PyObject *swig_obj[1] ;
8338
8339 arg2 = &temp2;
8340 arg3 = &temp3;
8341 if (!args) SWIG_fail;
8342 swig_obj[0] = args;
8343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 if (SWIG_IsTmpObj(res2)) {
8354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8355 } else {
8356 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8358 }
8359 if (SWIG_IsTmpObj(res3)) {
8360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8361 } else {
8362 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8364 }
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8374 int *arg2 = (int *) 0 ;
8375 int *arg3 = (int *) 0 ;
8376 void *argp1 = 0 ;
8377 int res1 = 0 ;
8378 int temp2 ;
8379 int res2 = SWIG_TMPOBJ ;
8380 int temp3 ;
8381 int res3 = SWIG_TMPOBJ ;
8382 PyObject *swig_obj[1] ;
8383
8384 arg2 = &temp2;
8385 arg3 = &temp3;
8386 if (!args) SWIG_fail;
8387 swig_obj[0] = args;
8388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8389 if (!SWIG_IsOK(res1)) {
8390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8391 }
8392 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8393 {
8394 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_Py_Void();
8398 if (SWIG_IsTmpObj(res2)) {
8399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8400 } else {
8401 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8403 }
8404 if (SWIG_IsTmpObj(res3)) {
8405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8406 } else {
8407 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8409 }
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8417 PyObject *resultobj = 0;
8418 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8419 double result;
8420 void *argp1 = 0 ;
8421 int res1 = 0 ;
8422 PyObject *swig_obj[1] ;
8423
8424 if (!args) SWIG_fail;
8425 swig_obj[0] = args;
8426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8427 if (!SWIG_IsOK(res1)) {
8428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8429 }
8430 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8431 {
8432 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 resultobj = SWIG_From_double(static_cast< double >(result));
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8445 double result;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 PyObject *swig_obj[1] ;
8449
8450 if (!args) SWIG_fail;
8451 swig_obj[0] = args;
8452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8453 if (!SWIG_IsOK(res1)) {
8454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8455 }
8456 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8457 {
8458 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_From_double(static_cast< double >(result));
8462 return resultobj;
8463 fail:
8464 return NULL;
8465 }
8466
8467
8468 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8469 PyObject *resultobj = 0;
8470 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8471 double arg2 ;
8472 void *argp1 = 0 ;
8473 int res1 = 0 ;
8474 double val2 ;
8475 int ecode2 = 0 ;
8476 PyObject * obj0 = 0 ;
8477 PyObject * obj1 = 0 ;
8478 char * kwnames[] = {
8479 (char *) "self",(char *) "length", NULL
8480 };
8481
8482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8486 }
8487 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8488 ecode2 = SWIG_AsVal_double(obj1, &val2);
8489 if (!SWIG_IsOK(ecode2)) {
8490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8491 }
8492 arg2 = static_cast< double >(val2);
8493 {
8494 (arg1)->SetVectorLength(arg2);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 resultobj = SWIG_Py_Void();
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj = 0;
8506 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8507 double arg2 ;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 double val2 ;
8511 int ecode2 = 0 ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char * kwnames[] = {
8515 (char *) "self",(char *) "degrees", NULL
8516 };
8517
8518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8520 if (!SWIG_IsOK(res1)) {
8521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8522 }
8523 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8524 ecode2 = SWIG_AsVal_double(obj1, &val2);
8525 if (!SWIG_IsOK(ecode2)) {
8526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8527 }
8528 arg2 = static_cast< double >(val2);
8529 {
8530 (arg1)->SetVectorAngle(arg2);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 resultobj = SWIG_Py_Void();
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj = 0;
8542 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8543 wxPoint2D *arg2 = 0 ;
8544 double result;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 wxPoint2D temp2 ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char * kwnames[] = {
8551 (char *) "self",(char *) "pt", NULL
8552 };
8553
8554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 arg2 = &temp2;
8562 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8563 }
8564 {
8565 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_From_double(static_cast< double >(result));
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 double result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_From_double(static_cast< double >(result));
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj = 0;
8612 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8613 wxPoint2D *arg2 = 0 ;
8614 double result;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 wxPoint2D temp2 ;
8618 PyObject * obj0 = 0 ;
8619 PyObject * obj1 = 0 ;
8620 char * kwnames[] = {
8621 (char *) "self",(char *) "vec", NULL
8622 };
8623
8624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8626 if (!SWIG_IsOK(res1)) {
8627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8628 }
8629 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8630 {
8631 arg2 = &temp2;
8632 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8633 }
8634 {
8635 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_From_double(static_cast< double >(result));
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj = 0;
8647 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8648 wxPoint2D *arg2 = 0 ;
8649 double result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 wxPoint2D temp2 ;
8653 PyObject * obj0 = 0 ;
8654 PyObject * obj1 = 0 ;
8655 char * kwnames[] = {
8656 (char *) "self",(char *) "vec", NULL
8657 };
8658
8659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8661 if (!SWIG_IsOK(res1)) {
8662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8663 }
8664 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8665 {
8666 arg2 = &temp2;
8667 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8668 }
8669 {
8670 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 resultobj = SWIG_From_double(static_cast< double >(result));
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8681 PyObject *resultobj = 0;
8682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8683 wxPoint2D result;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 PyObject *swig_obj[1] ;
8687
8688 if (!args) SWIG_fail;
8689 swig_obj[0] = args;
8690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8693 }
8694 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8695 {
8696 result = (arg1)->operator -();
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8707 PyObject *resultobj = 0;
8708 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8709 wxPoint2D *arg2 = 0 ;
8710 wxPoint2D *result = 0 ;
8711 void *argp1 = 0 ;
8712 int res1 = 0 ;
8713 wxPoint2D temp2 ;
8714 PyObject * obj0 = 0 ;
8715 PyObject * obj1 = 0 ;
8716 char * kwnames[] = {
8717 (char *) "self",(char *) "pt", NULL
8718 };
8719
8720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8722 if (!SWIG_IsOK(res1)) {
8723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8724 }
8725 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8726 {
8727 arg2 = &temp2;
8728 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8729 }
8730 {
8731 {
8732 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8733 result = (wxPoint2D *) &_result_ref;
8734 }
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj = 0;
8746 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8747 wxPoint2D *arg2 = 0 ;
8748 wxPoint2D *result = 0 ;
8749 void *argp1 = 0 ;
8750 int res1 = 0 ;
8751 wxPoint2D temp2 ;
8752 PyObject * obj0 = 0 ;
8753 PyObject * obj1 = 0 ;
8754 char * kwnames[] = {
8755 (char *) "self",(char *) "pt", NULL
8756 };
8757
8758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8760 if (!SWIG_IsOK(res1)) {
8761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8762 }
8763 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8764 {
8765 arg2 = &temp2;
8766 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8767 }
8768 {
8769 {
8770 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8771 result = (wxPoint2D *) &_result_ref;
8772 }
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D *arg2 = 0 ;
8786 wxPoint2D *result = 0 ;
8787 void *argp1 = 0 ;
8788 int res1 = 0 ;
8789 wxPoint2D temp2 ;
8790 PyObject * obj0 = 0 ;
8791 PyObject * obj1 = 0 ;
8792 char * kwnames[] = {
8793 (char *) "self",(char *) "pt", NULL
8794 };
8795
8796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8798 if (!SWIG_IsOK(res1)) {
8799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8800 }
8801 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8802 {
8803 arg2 = &temp2;
8804 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8805 }
8806 {
8807 {
8808 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8809 result = (wxPoint2D *) &_result_ref;
8810 }
8811 if (PyErr_Occurred()) SWIG_fail;
8812 }
8813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8814 return resultobj;
8815 fail:
8816 return NULL;
8817 }
8818
8819
8820 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8821 PyObject *resultobj = 0;
8822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8823 wxPoint2D *arg2 = 0 ;
8824 wxPoint2D *result = 0 ;
8825 void *argp1 = 0 ;
8826 int res1 = 0 ;
8827 wxPoint2D temp2 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 char * kwnames[] = {
8831 (char *) "self",(char *) "pt", NULL
8832 };
8833
8834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 {
8841 arg2 = &temp2;
8842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8843 }
8844 {
8845 {
8846 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8847 result = (wxPoint2D *) &_result_ref;
8848 }
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj = 0;
8860 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8861 PyObject *arg2 = (PyObject *) 0 ;
8862 bool result;
8863 void *argp1 = 0 ;
8864 int res1 = 0 ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 char * kwnames[] = {
8868 (char *) "self",(char *) "other", NULL
8869 };
8870
8871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8873 if (!SWIG_IsOK(res1)) {
8874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8875 }
8876 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8877 arg2 = obj1;
8878 {
8879 result = (bool)wxPoint2D___eq__(arg1,arg2);
8880 if (PyErr_Occurred()) SWIG_fail;
8881 }
8882 {
8883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8884 }
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 PyObject *arg2 = (PyObject *) 0 ;
8895 bool result;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 PyObject * obj0 = 0 ;
8899 PyObject * obj1 = 0 ;
8900 char * kwnames[] = {
8901 (char *) "self",(char *) "other", NULL
8902 };
8903
8904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8906 if (!SWIG_IsOK(res1)) {
8907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8908 }
8909 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8910 arg2 = obj1;
8911 {
8912 result = (bool)wxPoint2D___ne__(arg1,arg2);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 {
8916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8925 PyObject *resultobj = 0;
8926 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8927 double arg2 ;
8928 void *argp1 = 0 ;
8929 int res1 = 0 ;
8930 double val2 ;
8931 int ecode2 = 0 ;
8932 PyObject *swig_obj[2] ;
8933
8934 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8938 }
8939 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8940 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8941 if (!SWIG_IsOK(ecode2)) {
8942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8943 }
8944 arg2 = static_cast< double >(val2);
8945 if (arg1) (arg1)->m_x = arg2;
8946
8947 resultobj = SWIG_Py_Void();
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8955 PyObject *resultobj = 0;
8956 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8957 double result;
8958 void *argp1 = 0 ;
8959 int res1 = 0 ;
8960 PyObject *swig_obj[1] ;
8961
8962 if (!args) SWIG_fail;
8963 swig_obj[0] = args;
8964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8965 if (!SWIG_IsOK(res1)) {
8966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8967 }
8968 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8969 result = (double) ((arg1)->m_x);
8970 resultobj = SWIG_From_double(static_cast< double >(result));
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 PyObject *resultobj = 0;
8979 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8980 double arg2 ;
8981 void *argp1 = 0 ;
8982 int res1 = 0 ;
8983 double val2 ;
8984 int ecode2 = 0 ;
8985 PyObject *swig_obj[2] ;
8986
8987 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8989 if (!SWIG_IsOK(res1)) {
8990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8991 }
8992 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8993 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8994 if (!SWIG_IsOK(ecode2)) {
8995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8996 }
8997 arg2 = static_cast< double >(val2);
8998 if (arg1) (arg1)->m_y = arg2;
8999
9000 resultobj = SWIG_Py_Void();
9001 return resultobj;
9002 fail:
9003 return NULL;
9004 }
9005
9006
9007 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9008 PyObject *resultobj = 0;
9009 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9010 double result;
9011 void *argp1 = 0 ;
9012 int res1 = 0 ;
9013 PyObject *swig_obj[1] ;
9014
9015 if (!args) SWIG_fail;
9016 swig_obj[0] = args;
9017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 result = (double) ((arg1)->m_y);
9023 resultobj = SWIG_From_double(static_cast< double >(result));
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9031 PyObject *resultobj = 0;
9032 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9033 double arg2 = (double) 0 ;
9034 double arg3 = (double) 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 double val2 ;
9038 int ecode2 = 0 ;
9039 double val3 ;
9040 int ecode3 = 0 ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 PyObject * obj2 = 0 ;
9044 char * kwnames[] = {
9045 (char *) "self",(char *) "x",(char *) "y", NULL
9046 };
9047
9048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9050 if (!SWIG_IsOK(res1)) {
9051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9052 }
9053 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9054 if (obj1) {
9055 ecode2 = SWIG_AsVal_double(obj1, &val2);
9056 if (!SWIG_IsOK(ecode2)) {
9057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9058 }
9059 arg2 = static_cast< double >(val2);
9060 }
9061 if (obj2) {
9062 ecode3 = SWIG_AsVal_double(obj2, &val3);
9063 if (!SWIG_IsOK(ecode3)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9065 }
9066 arg3 = static_cast< double >(val3);
9067 }
9068 {
9069 wxPoint2D_Set(arg1,arg2,arg3);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_Py_Void();
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9080 PyObject *resultobj = 0;
9081 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9082 PyObject *result = 0 ;
9083 void *argp1 = 0 ;
9084 int res1 = 0 ;
9085 PyObject *swig_obj[1] ;
9086
9087 if (!args) SWIG_fail;
9088 swig_obj[0] = args;
9089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9092 }
9093 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9094 {
9095 result = (PyObject *)wxPoint2D_Get(arg1);
9096 if (PyErr_Occurred()) SWIG_fail;
9097 }
9098 resultobj = result;
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *obj;
9107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9108 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9109 return SWIG_Py_Void();
9110 }
9111
9112 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9113 return SWIG_Python_InitShadowInstance(args);
9114 }
9115
9116 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxDouble arg1 = (wxDouble) 0.0 ;
9119 wxDouble arg2 = (wxDouble) 0.0 ;
9120 wxDouble arg3 = (wxDouble) 0.0 ;
9121 wxDouble arg4 = (wxDouble) 0.0 ;
9122 wxRect2D *result = 0 ;
9123 void *argp1 ;
9124 int res1 = 0 ;
9125 void *argp2 ;
9126 int res2 = 0 ;
9127 void *argp3 ;
9128 int res3 = 0 ;
9129 void *argp4 ;
9130 int res4 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 PyObject * obj2 = 0 ;
9134 PyObject * obj3 = 0 ;
9135 char * kwnames[] = {
9136 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9137 };
9138
9139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9140 if (obj0) {
9141 {
9142 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9145 }
9146 if (!argp1) {
9147 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9148 } else {
9149 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9150 arg1 = *temp;
9151 if (SWIG_IsNewObj(res1)) delete temp;
9152 }
9153 }
9154 }
9155 if (obj1) {
9156 {
9157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9158 if (!SWIG_IsOK(res2)) {
9159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9160 }
9161 if (!argp2) {
9162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9163 } else {
9164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9165 arg2 = *temp;
9166 if (SWIG_IsNewObj(res2)) delete temp;
9167 }
9168 }
9169 }
9170 if (obj2) {
9171 {
9172 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9173 if (!SWIG_IsOK(res3)) {
9174 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9175 }
9176 if (!argp3) {
9177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9178 } else {
9179 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9180 arg3 = *temp;
9181 if (SWIG_IsNewObj(res3)) delete temp;
9182 }
9183 }
9184 }
9185 if (obj3) {
9186 {
9187 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9188 if (!SWIG_IsOK(res4)) {
9189 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9190 }
9191 if (!argp4) {
9192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9193 } else {
9194 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9195 arg4 = *temp;
9196 if (SWIG_IsNewObj(res4)) delete temp;
9197 }
9198 }
9199 }
9200 {
9201 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9212 PyObject *resultobj = 0;
9213 wxRect2D *arg1 = (wxRect2D *) 0 ;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 PyObject *swig_obj[1] ;
9217
9218 if (!args) SWIG_fail;
9219 swig_obj[0] = args;
9220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9221 if (!SWIG_IsOK(res1)) {
9222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9223 }
9224 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9225 {
9226 delete arg1;
9227
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_Py_Void();
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *resultobj = 0;
9239 wxRect2D *arg1 = (wxRect2D *) 0 ;
9240 wxPoint2D result;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9250 }
9251 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9252 {
9253 result = (arg1)->GetPosition();
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9257 return resultobj;
9258 fail:
9259 return NULL;
9260 }
9261
9262
9263 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9264 PyObject *resultobj = 0;
9265 wxRect2D *arg1 = (wxRect2D *) 0 ;
9266 wxSize result;
9267 void *argp1 = 0 ;
9268 int res1 = 0 ;
9269 PyObject *swig_obj[1] ;
9270
9271 if (!args) SWIG_fail;
9272 swig_obj[0] = args;
9273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9274 if (!SWIG_IsOK(res1)) {
9275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9276 }
9277 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9278 {
9279 result = (arg1)->GetSize();
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9290 PyObject *resultobj = 0;
9291 wxRect2D *arg1 = (wxRect2D *) 0 ;
9292 wxDouble result;
9293 void *argp1 = 0 ;
9294 int res1 = 0 ;
9295 PyObject *swig_obj[1] ;
9296
9297 if (!args) SWIG_fail;
9298 swig_obj[0] = args;
9299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9300 if (!SWIG_IsOK(res1)) {
9301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9302 }
9303 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9304 {
9305 result = ((wxRect2D const *)arg1)->GetLeft();
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj = 0;
9317 wxRect2D *arg1 = (wxRect2D *) 0 ;
9318 wxDouble arg2 ;
9319 void *argp1 = 0 ;
9320 int res1 = 0 ;
9321 void *argp2 ;
9322 int res2 = 0 ;
9323 PyObject * obj0 = 0 ;
9324 PyObject * obj1 = 0 ;
9325 char * kwnames[] = {
9326 (char *) "self",(char *) "n", NULL
9327 };
9328
9329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9333 }
9334 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9335 {
9336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9337 if (!SWIG_IsOK(res2)) {
9338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9339 }
9340 if (!argp2) {
9341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9342 } else {
9343 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9344 arg2 = *temp;
9345 if (SWIG_IsNewObj(res2)) delete temp;
9346 }
9347 }
9348 {
9349 (arg1)->SetLeft(arg2);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_Py_Void();
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = 0;
9361 wxRect2D *arg1 = (wxRect2D *) 0 ;
9362 wxDouble arg2 ;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 void *argp2 ;
9366 int res2 = 0 ;
9367 PyObject * obj0 = 0 ;
9368 PyObject * obj1 = 0 ;
9369 char * kwnames[] = {
9370 (char *) "self",(char *) "n", NULL
9371 };
9372
9373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9375 if (!SWIG_IsOK(res1)) {
9376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9377 }
9378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9379 {
9380 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9381 if (!SWIG_IsOK(res2)) {
9382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9383 }
9384 if (!argp2) {
9385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9386 } else {
9387 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9388 arg2 = *temp;
9389 if (SWIG_IsNewObj(res2)) delete temp;
9390 }
9391 }
9392 {
9393 (arg1)->MoveLeftTo(arg2);
9394 if (PyErr_Occurred()) SWIG_fail;
9395 }
9396 resultobj = SWIG_Py_Void();
9397 return resultobj;
9398 fail:
9399 return NULL;
9400 }
9401
9402
9403 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9404 PyObject *resultobj = 0;
9405 wxRect2D *arg1 = (wxRect2D *) 0 ;
9406 wxDouble result;
9407 void *argp1 = 0 ;
9408 int res1 = 0 ;
9409 PyObject *swig_obj[1] ;
9410
9411 if (!args) SWIG_fail;
9412 swig_obj[0] = args;
9413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9414 if (!SWIG_IsOK(res1)) {
9415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9416 }
9417 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9418 {
9419 result = ((wxRect2D const *)arg1)->GetTop();
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 wxRect2D *arg1 = (wxRect2D *) 0 ;
9432 wxDouble arg2 ;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 void *argp2 ;
9436 int res2 = 0 ;
9437 PyObject * obj0 = 0 ;
9438 PyObject * obj1 = 0 ;
9439 char * kwnames[] = {
9440 (char *) "self",(char *) "n", NULL
9441 };
9442
9443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9445 if (!SWIG_IsOK(res1)) {
9446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9447 }
9448 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9449 {
9450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9451 if (!SWIG_IsOK(res2)) {
9452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9453 }
9454 if (!argp2) {
9455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9456 } else {
9457 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9458 arg2 = *temp;
9459 if (SWIG_IsNewObj(res2)) delete temp;
9460 }
9461 }
9462 {
9463 (arg1)->SetTop(arg2);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_Py_Void();
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj = 0;
9475 wxRect2D *arg1 = (wxRect2D *) 0 ;
9476 wxDouble arg2 ;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 void *argp2 ;
9480 int res2 = 0 ;
9481 PyObject * obj0 = 0 ;
9482 PyObject * obj1 = 0 ;
9483 char * kwnames[] = {
9484 (char *) "self",(char *) "n", NULL
9485 };
9486
9487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9491 }
9492 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9493 {
9494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9495 if (!SWIG_IsOK(res2)) {
9496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9497 }
9498 if (!argp2) {
9499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9500 } else {
9501 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9502 arg2 = *temp;
9503 if (SWIG_IsNewObj(res2)) delete temp;
9504 }
9505 }
9506 {
9507 (arg1)->MoveTopTo(arg2);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_Py_Void();
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9518 PyObject *resultobj = 0;
9519 wxRect2D *arg1 = (wxRect2D *) 0 ;
9520 wxDouble result;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 PyObject *swig_obj[1] ;
9524
9525 if (!args) SWIG_fail;
9526 swig_obj[0] = args;
9527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9528 if (!SWIG_IsOK(res1)) {
9529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9530 }
9531 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9532 {
9533 result = ((wxRect2D const *)arg1)->GetBottom();
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj = 0;
9545 wxRect2D *arg1 = (wxRect2D *) 0 ;
9546 wxDouble arg2 ;
9547 void *argp1 = 0 ;
9548 int res1 = 0 ;
9549 void *argp2 ;
9550 int res2 = 0 ;
9551 PyObject * obj0 = 0 ;
9552 PyObject * obj1 = 0 ;
9553 char * kwnames[] = {
9554 (char *) "self",(char *) "n", NULL
9555 };
9556
9557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9561 }
9562 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9563 {
9564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9565 if (!SWIG_IsOK(res2)) {
9566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9567 }
9568 if (!argp2) {
9569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9570 } else {
9571 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9572 arg2 = *temp;
9573 if (SWIG_IsNewObj(res2)) delete temp;
9574 }
9575 }
9576 {
9577 (arg1)->SetBottom(arg2);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_Py_Void();
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxRect2D *arg1 = (wxRect2D *) 0 ;
9590 wxDouble arg2 ;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 void *argp2 ;
9594 int res2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "n", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9605 }
9606 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9607 {
9608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9609 if (!SWIG_IsOK(res2)) {
9610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9611 }
9612 if (!argp2) {
9613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9614 } else {
9615 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9616 arg2 = *temp;
9617 if (SWIG_IsNewObj(res2)) delete temp;
9618 }
9619 }
9620 {
9621 (arg1)->MoveBottomTo(arg2);
9622 if (PyErr_Occurred()) SWIG_fail;
9623 }
9624 resultobj = SWIG_Py_Void();
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxRect2D *arg1 = (wxRect2D *) 0 ;
9634 wxDouble result;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject *swig_obj[1] ;
9638
9639 if (!args) SWIG_fail;
9640 swig_obj[0] = args;
9641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9644 }
9645 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9646 {
9647 result = ((wxRect2D const *)arg1)->GetRight();
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj = 0;
9659 wxRect2D *arg1 = (wxRect2D *) 0 ;
9660 wxDouble arg2 ;
9661 void *argp1 = 0 ;
9662 int res1 = 0 ;
9663 void *argp2 ;
9664 int res2 = 0 ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 char * kwnames[] = {
9668 (char *) "self",(char *) "n", NULL
9669 };
9670
9671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9673 if (!SWIG_IsOK(res1)) {
9674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9675 }
9676 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9677 {
9678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9679 if (!SWIG_IsOK(res2)) {
9680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9681 }
9682 if (!argp2) {
9683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9684 } else {
9685 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9686 arg2 = *temp;
9687 if (SWIG_IsNewObj(res2)) delete temp;
9688 }
9689 }
9690 {
9691 (arg1)->SetRight(arg2);
9692 if (PyErr_Occurred()) SWIG_fail;
9693 }
9694 resultobj = SWIG_Py_Void();
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxRect2D *arg1 = (wxRect2D *) 0 ;
9704 wxDouble arg2 ;
9705 void *argp1 = 0 ;
9706 int res1 = 0 ;
9707 void *argp2 ;
9708 int res2 = 0 ;
9709 PyObject * obj0 = 0 ;
9710 PyObject * obj1 = 0 ;
9711 char * kwnames[] = {
9712 (char *) "self",(char *) "n", NULL
9713 };
9714
9715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9717 if (!SWIG_IsOK(res1)) {
9718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9719 }
9720 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9721 {
9722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9723 if (!SWIG_IsOK(res2)) {
9724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9725 }
9726 if (!argp2) {
9727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9728 } else {
9729 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9730 arg2 = *temp;
9731 if (SWIG_IsNewObj(res2)) delete temp;
9732 }
9733 }
9734 {
9735 (arg1)->MoveRightTo(arg2);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxRect2D *arg1 = (wxRect2D *) 0 ;
9748 wxPoint2D result;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 PyObject *swig_obj[1] ;
9752
9753 if (!args) SWIG_fail;
9754 swig_obj[0] = args;
9755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9758 }
9759 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9760 {
9761 result = ((wxRect2D const *)arg1)->GetLeftTop();
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj = 0;
9773 wxRect2D *arg1 = (wxRect2D *) 0 ;
9774 wxPoint2D *arg2 = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 wxPoint2D temp2 ;
9778 PyObject * obj0 = 0 ;
9779 PyObject * obj1 = 0 ;
9780 char * kwnames[] = {
9781 (char *) "self",(char *) "pt", NULL
9782 };
9783
9784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9786 if (!SWIG_IsOK(res1)) {
9787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9788 }
9789 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9790 {
9791 arg2 = &temp2;
9792 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9793 }
9794 {
9795 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_Py_Void();
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9806 PyObject *resultobj = 0;
9807 wxRect2D *arg1 = (wxRect2D *) 0 ;
9808 wxPoint2D *arg2 = 0 ;
9809 void *argp1 = 0 ;
9810 int res1 = 0 ;
9811 wxPoint2D temp2 ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char * kwnames[] = {
9815 (char *) "self",(char *) "pt", NULL
9816 };
9817
9818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9820 if (!SWIG_IsOK(res1)) {
9821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9822 }
9823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9824 {
9825 arg2 = &temp2;
9826 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9827 }
9828 {
9829 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_Py_Void();
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *resultobj = 0;
9841 wxRect2D *arg1 = (wxRect2D *) 0 ;
9842 wxPoint2D result;
9843 void *argp1 = 0 ;
9844 int res1 = 0 ;
9845 PyObject *swig_obj[1] ;
9846
9847 if (!args) SWIG_fail;
9848 swig_obj[0] = args;
9849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9850 if (!SWIG_IsOK(res1)) {
9851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9852 }
9853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9854 {
9855 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9856 if (PyErr_Occurred()) SWIG_fail;
9857 }
9858 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj = 0;
9867 wxRect2D *arg1 = (wxRect2D *) 0 ;
9868 wxPoint2D *arg2 = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 wxPoint2D temp2 ;
9872 PyObject * obj0 = 0 ;
9873 PyObject * obj1 = 0 ;
9874 char * kwnames[] = {
9875 (char *) "self",(char *) "pt", NULL
9876 };
9877
9878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9880 if (!SWIG_IsOK(res1)) {
9881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9882 }
9883 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9884 {
9885 arg2 = &temp2;
9886 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9887 }
9888 {
9889 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9890 if (PyErr_Occurred()) SWIG_fail;
9891 }
9892 resultobj = SWIG_Py_Void();
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj = 0;
9901 wxRect2D *arg1 = (wxRect2D *) 0 ;
9902 wxPoint2D *arg2 = 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 wxPoint2D temp2 ;
9906 PyObject * obj0 = 0 ;
9907 PyObject * obj1 = 0 ;
9908 char * kwnames[] = {
9909 (char *) "self",(char *) "pt", NULL
9910 };
9911
9912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9916 }
9917 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9918 {
9919 arg2 = &temp2;
9920 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9921 }
9922 {
9923 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *resultobj = 0;
9935 wxRect2D *arg1 = (wxRect2D *) 0 ;
9936 wxPoint2D result;
9937 void *argp1 = 0 ;
9938 int res1 = 0 ;
9939 PyObject *swig_obj[1] ;
9940
9941 if (!args) SWIG_fail;
9942 swig_obj[0] = args;
9943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9944 if (!SWIG_IsOK(res1)) {
9945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9946 }
9947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9948 {
9949 result = ((wxRect2D const *)arg1)->GetRightTop();
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj = 0;
9961 wxRect2D *arg1 = (wxRect2D *) 0 ;
9962 wxPoint2D *arg2 = 0 ;
9963 void *argp1 = 0 ;
9964 int res1 = 0 ;
9965 wxPoint2D temp2 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char * kwnames[] = {
9969 (char *) "self",(char *) "pt", NULL
9970 };
9971
9972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9976 }
9977 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9978 {
9979 arg2 = &temp2;
9980 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9981 }
9982 {
9983 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxRect2D *arg1 = (wxRect2D *) 0 ;
9996 wxPoint2D *arg2 = 0 ;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 wxPoint2D temp2 ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char * kwnames[] = {
10003 (char *) "self",(char *) "pt", NULL
10004 };
10005
10006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10008 if (!SWIG_IsOK(res1)) {
10009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10010 }
10011 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10012 {
10013 arg2 = &temp2;
10014 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10015 }
10016 {
10017 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxRect2D *arg1 = (wxRect2D *) 0 ;
10030 wxPoint2D result;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 PyObject *swig_obj[1] ;
10034
10035 if (!args) SWIG_fail;
10036 swig_obj[0] = args;
10037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10040 }
10041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10042 {
10043 result = ((wxRect2D const *)arg1)->GetRightBottom();
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxRect2D *arg1 = (wxRect2D *) 0 ;
10056 wxPoint2D *arg2 = 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 wxPoint2D temp2 ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "pt", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10070 }
10071 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10072 {
10073 arg2 = &temp2;
10074 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10075 }
10076 {
10077 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxRect2D *arg1 = (wxRect2D *) 0 ;
10090 wxPoint2D *arg2 = 0 ;
10091 void *argp1 = 0 ;
10092 int res1 = 0 ;
10093 wxPoint2D temp2 ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "pt", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10104 }
10105 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10106 {
10107 arg2 = &temp2;
10108 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10109 }
10110 {
10111 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 resultobj = SWIG_Py_Void();
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122 PyObject *resultobj = 0;
10123 wxRect2D *arg1 = (wxRect2D *) 0 ;
10124 wxPoint2D result;
10125 void *argp1 = 0 ;
10126 int res1 = 0 ;
10127 PyObject *swig_obj[1] ;
10128
10129 if (!args) SWIG_fail;
10130 swig_obj[0] = args;
10131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10132 if (!SWIG_IsOK(res1)) {
10133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10134 }
10135 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10136 {
10137 result = ((wxRect2D const *)arg1)->GetCentre();
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10141 return resultobj;
10142 fail:
10143 return NULL;
10144 }
10145
10146
10147 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj = 0;
10149 wxRect2D *arg1 = (wxRect2D *) 0 ;
10150 wxPoint2D *arg2 = 0 ;
10151 void *argp1 = 0 ;
10152 int res1 = 0 ;
10153 wxPoint2D temp2 ;
10154 PyObject * obj0 = 0 ;
10155 PyObject * obj1 = 0 ;
10156 char * kwnames[] = {
10157 (char *) "self",(char *) "pt", NULL
10158 };
10159
10160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10162 if (!SWIG_IsOK(res1)) {
10163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10164 }
10165 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10166 {
10167 arg2 = &temp2;
10168 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10169 }
10170 {
10171 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 resultobj = SWIG_Py_Void();
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj = 0;
10183 wxRect2D *arg1 = (wxRect2D *) 0 ;
10184 wxPoint2D *arg2 = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 wxPoint2D temp2 ;
10188 PyObject * obj0 = 0 ;
10189 PyObject * obj1 = 0 ;
10190 char * kwnames[] = {
10191 (char *) "self",(char *) "pt", NULL
10192 };
10193
10194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10196 if (!SWIG_IsOK(res1)) {
10197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10198 }
10199 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10200 {
10201 arg2 = &temp2;
10202 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10203 }
10204 {
10205 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 resultobj = SWIG_Py_Void();
10209 return resultobj;
10210 fail:
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10216 PyObject *resultobj = 0;
10217 wxRect2D *arg1 = (wxRect2D *) 0 ;
10218 wxPoint2D *arg2 = 0 ;
10219 wxOutCode result;
10220 void *argp1 = 0 ;
10221 int res1 = 0 ;
10222 wxPoint2D temp2 ;
10223 PyObject * obj0 = 0 ;
10224 PyObject * obj1 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "pt", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10233 }
10234 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10235 {
10236 arg2 = &temp2;
10237 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10238 }
10239 {
10240 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_From_int(static_cast< int >(result));
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxRect2D *arg1 = (wxRect2D *) 0 ;
10253 wxPoint2D *arg2 = 0 ;
10254 bool result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 wxPoint2D temp2 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "pt", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10268 }
10269 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10270 {
10271 arg2 = &temp2;
10272 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10273 }
10274 {
10275 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 {
10279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10280 }
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10288 PyObject *resultobj = 0;
10289 wxRect2D *arg1 = (wxRect2D *) 0 ;
10290 wxRect2D *arg2 = 0 ;
10291 bool result;
10292 void *argp1 = 0 ;
10293 int res1 = 0 ;
10294 wxRect2D temp2 ;
10295 PyObject * obj0 = 0 ;
10296 PyObject * obj1 = 0 ;
10297 char * kwnames[] = {
10298 (char *) "self",(char *) "rect", NULL
10299 };
10300
10301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10305 }
10306 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10307 {
10308 arg2 = &temp2;
10309 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10310 }
10311 {
10312 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 {
10316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10317 }
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10325 PyObject *resultobj = 0;
10326 wxRect2D *arg1 = (wxRect2D *) 0 ;
10327 bool result;
10328 void *argp1 = 0 ;
10329 int res1 = 0 ;
10330 PyObject *swig_obj[1] ;
10331
10332 if (!args) SWIG_fail;
10333 swig_obj[0] = args;
10334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10337 }
10338 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10339 {
10340 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 {
10344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10345 }
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj = 0;
10354 wxRect2D *arg1 = (wxRect2D *) 0 ;
10355 wxRect2D *arg2 = 0 ;
10356 bool result;
10357 void *argp1 = 0 ;
10358 int res1 = 0 ;
10359 wxRect2D temp2 ;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char * kwnames[] = {
10363 (char *) "self",(char *) "rect", NULL
10364 };
10365
10366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10368 if (!SWIG_IsOK(res1)) {
10369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10370 }
10371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10372 {
10373 arg2 = &temp2;
10374 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10375 }
10376 {
10377 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10390 PyObject *resultobj = 0;
10391 wxRect2D *arg1 = (wxRect2D *) 0 ;
10392 wxDouble arg2 ;
10393 wxDouble arg3 ;
10394 void *argp1 = 0 ;
10395 int res1 = 0 ;
10396 void *argp2 ;
10397 int res2 = 0 ;
10398 void *argp3 ;
10399 int res3 = 0 ;
10400
10401 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10405 }
10406 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10407 {
10408 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10409 if (!SWIG_IsOK(res2)) {
10410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10411 }
10412 if (!argp2) {
10413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10414 } else {
10415 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10416 arg2 = *temp;
10417 if (SWIG_IsNewObj(res2)) delete temp;
10418 }
10419 }
10420 {
10421 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10422 if (!SWIG_IsOK(res3)) {
10423 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10424 }
10425 if (!argp3) {
10426 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10427 } else {
10428 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10429 arg3 = *temp;
10430 if (SWIG_IsNewObj(res3)) delete temp;
10431 }
10432 }
10433 {
10434 (arg1)->Inset(arg2,arg3);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 resultobj = SWIG_Py_Void();
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10445 PyObject *resultobj = 0;
10446 wxRect2D *arg1 = (wxRect2D *) 0 ;
10447 wxDouble arg2 ;
10448 wxDouble arg3 ;
10449 wxDouble arg4 ;
10450 wxDouble arg5 ;
10451 void *argp1 = 0 ;
10452 int res1 = 0 ;
10453 void *argp2 ;
10454 int res2 = 0 ;
10455 void *argp3 ;
10456 int res3 = 0 ;
10457 void *argp4 ;
10458 int res4 = 0 ;
10459 void *argp5 ;
10460 int res5 = 0 ;
10461
10462 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10466 }
10467 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10468 {
10469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10470 if (!SWIG_IsOK(res2)) {
10471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10472 }
10473 if (!argp2) {
10474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10475 } else {
10476 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10477 arg2 = *temp;
10478 if (SWIG_IsNewObj(res2)) delete temp;
10479 }
10480 }
10481 {
10482 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10483 if (!SWIG_IsOK(res3)) {
10484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10485 }
10486 if (!argp3) {
10487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10488 } else {
10489 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10490 arg3 = *temp;
10491 if (SWIG_IsNewObj(res3)) delete temp;
10492 }
10493 }
10494 {
10495 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10496 if (!SWIG_IsOK(res4)) {
10497 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10498 }
10499 if (!argp4) {
10500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10501 } else {
10502 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10503 arg4 = *temp;
10504 if (SWIG_IsNewObj(res4)) delete temp;
10505 }
10506 }
10507 {
10508 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10509 if (!SWIG_IsOK(res5)) {
10510 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10511 }
10512 if (!argp5) {
10513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10514 } else {
10515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10516 arg5 = *temp;
10517 if (SWIG_IsNewObj(res5)) delete temp;
10518 }
10519 }
10520 {
10521 (arg1)->Inset(arg2,arg3,arg4,arg5);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_Py_Void();
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10532 int argc;
10533 PyObject *argv[6];
10534
10535 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10536 --argc;
10537 if (argc == 3) {
10538 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10539 }
10540 if (argc == 5) {
10541 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10542 }
10543
10544 fail:
10545 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10551 PyObject *resultobj = 0;
10552 wxRect2D *arg1 = (wxRect2D *) 0 ;
10553 wxPoint2D *arg2 = 0 ;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 wxPoint2D temp2 ;
10557 PyObject * obj0 = 0 ;
10558 PyObject * obj1 = 0 ;
10559 char * kwnames[] = {
10560 (char *) "self",(char *) "pt", NULL
10561 };
10562
10563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10565 if (!SWIG_IsOK(res1)) {
10566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10567 }
10568 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10569 {
10570 arg2 = &temp2;
10571 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10572 }
10573 {
10574 (arg1)->Offset((wxPoint2D const &)*arg2);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_Py_Void();
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj = 0;
10586 wxRect2D *arg1 = (wxRect2D *) 0 ;
10587 wxRect2D *arg2 = 0 ;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 wxRect2D temp2 ;
10591 PyObject * obj0 = 0 ;
10592 PyObject * obj1 = 0 ;
10593 char * kwnames[] = {
10594 (char *) "self",(char *) "rect", NULL
10595 };
10596
10597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10599 if (!SWIG_IsOK(res1)) {
10600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10601 }
10602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10603 {
10604 arg2 = &temp2;
10605 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10606 }
10607 {
10608 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10609 if (PyErr_Occurred()) SWIG_fail;
10610 }
10611 resultobj = SWIG_Py_Void();
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj = 0;
10620 wxRect2D *arg1 = (wxRect2D *) 0 ;
10621 int arg2 ;
10622 int arg3 ;
10623 wxPoint2D result;
10624 void *argp1 = 0 ;
10625 int res1 = 0 ;
10626 int val2 ;
10627 int ecode2 = 0 ;
10628 int val3 ;
10629 int ecode3 = 0 ;
10630 PyObject * obj0 = 0 ;
10631 PyObject * obj1 = 0 ;
10632 PyObject * obj2 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10641 }
10642 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10643 ecode2 = SWIG_AsVal_int(obj1, &val2);
10644 if (!SWIG_IsOK(ecode2)) {
10645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10646 }
10647 arg2 = static_cast< int >(val2);
10648 ecode3 = SWIG_AsVal_int(obj2, &val3);
10649 if (!SWIG_IsOK(ecode3)) {
10650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10651 }
10652 arg3 = static_cast< int >(val3);
10653 {
10654 result = (arg1)->Interpolate(arg2,arg3);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj = 0;
10666 wxRect2D *arg1 = (wxRect2D *) 0 ;
10667 wxRect2D *arg2 = 0 ;
10668 void *argp1 = 0 ;
10669 int res1 = 0 ;
10670 wxRect2D temp2 ;
10671 PyObject * obj0 = 0 ;
10672 PyObject * obj1 = 0 ;
10673 char * kwnames[] = {
10674 (char *) "self",(char *) "otherRect", NULL
10675 };
10676
10677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10679 if (!SWIG_IsOK(res1)) {
10680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10681 }
10682 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10683 {
10684 arg2 = &temp2;
10685 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10686 }
10687 {
10688 (arg1)->Intersect((wxRect2D const &)*arg2);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_Py_Void();
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj = 0;
10700 wxRect2D *arg1 = (wxRect2D *) 0 ;
10701 wxRect2D *arg2 = 0 ;
10702 wxRect2D result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 wxRect2D temp2 ;
10706 PyObject * obj0 = 0 ;
10707 PyObject * obj1 = 0 ;
10708 char * kwnames[] = {
10709 (char *) "self",(char *) "otherRect", NULL
10710 };
10711
10712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10714 if (!SWIG_IsOK(res1)) {
10715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10716 }
10717 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10718 {
10719 arg2 = &temp2;
10720 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10721 }
10722 {
10723 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10734 PyObject *resultobj = 0;
10735 wxRect2D *arg1 = (wxRect2D *) 0 ;
10736 wxRect2D *arg2 = 0 ;
10737 bool result;
10738 void *argp1 = 0 ;
10739 int res1 = 0 ;
10740 wxRect2D temp2 ;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "self",(char *) "rect", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10751 }
10752 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10753 {
10754 arg2 = &temp2;
10755 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10756 }
10757 {
10758 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10763 }
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj = 0;
10772 wxRect2D *arg1 = (wxRect2D *) 0 ;
10773 wxRect2D *arg2 = 0 ;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 wxRect2D temp2 ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "otherRect", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10787 }
10788 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10789 {
10790 arg2 = &temp2;
10791 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10792 }
10793 {
10794 (arg1)->Union((wxRect2D const &)*arg2);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 resultobj = SWIG_Py_Void();
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxRect2D *arg1 = (wxRect2D *) 0 ;
10807 wxRect2D *arg2 = 0 ;
10808 wxRect2D result;
10809 void *argp1 = 0 ;
10810 int res1 = 0 ;
10811 wxRect2D temp2 ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "otherRect", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10822 }
10823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10824 {
10825 arg2 = &temp2;
10826 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10827 }
10828 {
10829 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10840 PyObject *resultobj = 0;
10841 wxRect2D *arg1 = (wxRect2D *) 0 ;
10842 wxDouble arg2 ;
10843 void *argp1 = 0 ;
10844 int res1 = 0 ;
10845 void *argp2 ;
10846 int res2 = 0 ;
10847
10848 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10850 if (!SWIG_IsOK(res1)) {
10851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10852 }
10853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10854 {
10855 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10856 if (!SWIG_IsOK(res2)) {
10857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10858 }
10859 if (!argp2) {
10860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10861 } else {
10862 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10863 arg2 = *temp;
10864 if (SWIG_IsNewObj(res2)) delete temp;
10865 }
10866 }
10867 {
10868 (arg1)->Scale(arg2);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 resultobj = SWIG_Py_Void();
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10879 PyObject *resultobj = 0;
10880 wxRect2D *arg1 = (wxRect2D *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 void *argp1 = 0 ;
10884 int res1 = 0 ;
10885 int val2 ;
10886 int ecode2 = 0 ;
10887 int val3 ;
10888 int ecode3 = 0 ;
10889
10890 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10892 if (!SWIG_IsOK(res1)) {
10893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10894 }
10895 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10896 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10897 if (!SWIG_IsOK(ecode2)) {
10898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10899 }
10900 arg2 = static_cast< int >(val2);
10901 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10902 if (!SWIG_IsOK(ecode3)) {
10903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10904 }
10905 arg3 = static_cast< int >(val3);
10906 {
10907 (arg1)->Scale(arg2,arg3);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_Py_Void();
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10918 int argc;
10919 PyObject *argv[4];
10920
10921 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10922 --argc;
10923 if (argc == 2) {
10924 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10925 }
10926 if (argc == 3) {
10927 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10928 }
10929
10930 fail:
10931 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10932 return NULL;
10933 }
10934
10935
10936 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj = 0;
10938 wxRect2D *arg1 = (wxRect2D *) 0 ;
10939 PyObject *arg2 = (PyObject *) 0 ;
10940 bool result;
10941 void *argp1 = 0 ;
10942 int res1 = 0 ;
10943 PyObject * obj0 = 0 ;
10944 PyObject * obj1 = 0 ;
10945 char * kwnames[] = {
10946 (char *) "self",(char *) "other", NULL
10947 };
10948
10949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10951 if (!SWIG_IsOK(res1)) {
10952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10953 }
10954 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10955 arg2 = obj1;
10956 {
10957 result = (bool)wxRect2D___eq__(arg1,arg2);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 {
10961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10962 }
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj = 0;
10971 wxRect2D *arg1 = (wxRect2D *) 0 ;
10972 PyObject *arg2 = (PyObject *) 0 ;
10973 bool result;
10974 void *argp1 = 0 ;
10975 int res1 = 0 ;
10976 PyObject * obj0 = 0 ;
10977 PyObject * obj1 = 0 ;
10978 char * kwnames[] = {
10979 (char *) "self",(char *) "other", NULL
10980 };
10981
10982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10984 if (!SWIG_IsOK(res1)) {
10985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10986 }
10987 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10988 arg2 = obj1;
10989 {
10990 result = (bool)wxRect2D___ne__(arg1,arg2);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10995 }
10996 return resultobj;
10997 fail:
10998 return NULL;
10999 }
11000
11001
11002 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11003 PyObject *resultobj = 0;
11004 wxRect2D *arg1 = (wxRect2D *) 0 ;
11005 wxDouble arg2 ;
11006 void *argp1 = 0 ;
11007 int res1 = 0 ;
11008 void *argp2 ;
11009 int res2 = 0 ;
11010 PyObject *swig_obj[2] ;
11011
11012 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11014 if (!SWIG_IsOK(res1)) {
11015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11016 }
11017 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11018 {
11019 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11020 if (!SWIG_IsOK(res2)) {
11021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11022 }
11023 if (!argp2) {
11024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11025 } else {
11026 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11027 arg2 = *temp;
11028 if (SWIG_IsNewObj(res2)) delete temp;
11029 }
11030 }
11031 if (arg1) (arg1)->m_x = arg2;
11032
11033 resultobj = SWIG_Py_Void();
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11041 PyObject *resultobj = 0;
11042 wxRect2D *arg1 = (wxRect2D *) 0 ;
11043 wxDouble result;
11044 void *argp1 = 0 ;
11045 int res1 = 0 ;
11046 PyObject *swig_obj[1] ;
11047
11048 if (!args) SWIG_fail;
11049 swig_obj[0] = args;
11050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11051 if (!SWIG_IsOK(res1)) {
11052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11053 }
11054 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11055 result = ((arg1)->m_x);
11056 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11064 PyObject *resultobj = 0;
11065 wxRect2D *arg1 = (wxRect2D *) 0 ;
11066 wxDouble arg2 ;
11067 void *argp1 = 0 ;
11068 int res1 = 0 ;
11069 void *argp2 ;
11070 int res2 = 0 ;
11071 PyObject *swig_obj[2] ;
11072
11073 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11075 if (!SWIG_IsOK(res1)) {
11076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11077 }
11078 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11079 {
11080 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11081 if (!SWIG_IsOK(res2)) {
11082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11083 }
11084 if (!argp2) {
11085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11086 } else {
11087 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11088 arg2 = *temp;
11089 if (SWIG_IsNewObj(res2)) delete temp;
11090 }
11091 }
11092 if (arg1) (arg1)->m_y = arg2;
11093
11094 resultobj = SWIG_Py_Void();
11095 return resultobj;
11096 fail:
11097 return NULL;
11098 }
11099
11100
11101 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11102 PyObject *resultobj = 0;
11103 wxRect2D *arg1 = (wxRect2D *) 0 ;
11104 wxDouble result;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 PyObject *swig_obj[1] ;
11108
11109 if (!args) SWIG_fail;
11110 swig_obj[0] = args;
11111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11114 }
11115 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11116 result = ((arg1)->m_y);
11117 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125 PyObject *resultobj = 0;
11126 wxRect2D *arg1 = (wxRect2D *) 0 ;
11127 wxDouble arg2 ;
11128 void *argp1 = 0 ;
11129 int res1 = 0 ;
11130 void *argp2 ;
11131 int res2 = 0 ;
11132 PyObject *swig_obj[2] ;
11133
11134 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11136 if (!SWIG_IsOK(res1)) {
11137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11138 }
11139 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11140 {
11141 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11142 if (!SWIG_IsOK(res2)) {
11143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11144 }
11145 if (!argp2) {
11146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11147 } else {
11148 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11149 arg2 = *temp;
11150 if (SWIG_IsNewObj(res2)) delete temp;
11151 }
11152 }
11153 if (arg1) (arg1)->m_width = arg2;
11154
11155 resultobj = SWIG_Py_Void();
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163 PyObject *resultobj = 0;
11164 wxRect2D *arg1 = (wxRect2D *) 0 ;
11165 wxDouble result;
11166 void *argp1 = 0 ;
11167 int res1 = 0 ;
11168 PyObject *swig_obj[1] ;
11169
11170 if (!args) SWIG_fail;
11171 swig_obj[0] = args;
11172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11173 if (!SWIG_IsOK(res1)) {
11174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11175 }
11176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11177 result = ((arg1)->m_width);
11178 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186 PyObject *resultobj = 0;
11187 wxRect2D *arg1 = (wxRect2D *) 0 ;
11188 wxDouble arg2 ;
11189 void *argp1 = 0 ;
11190 int res1 = 0 ;
11191 void *argp2 ;
11192 int res2 = 0 ;
11193 PyObject *swig_obj[2] ;
11194
11195 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11197 if (!SWIG_IsOK(res1)) {
11198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11199 }
11200 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11201 {
11202 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11203 if (!SWIG_IsOK(res2)) {
11204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11205 }
11206 if (!argp2) {
11207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11208 } else {
11209 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11210 arg2 = *temp;
11211 if (SWIG_IsNewObj(res2)) delete temp;
11212 }
11213 }
11214 if (arg1) (arg1)->m_height = arg2;
11215
11216 resultobj = SWIG_Py_Void();
11217 return resultobj;
11218 fail:
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11224 PyObject *resultobj = 0;
11225 wxRect2D *arg1 = (wxRect2D *) 0 ;
11226 wxDouble result;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 PyObject *swig_obj[1] ;
11230
11231 if (!args) SWIG_fail;
11232 swig_obj[0] = args;
11233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11234 if (!SWIG_IsOK(res1)) {
11235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11236 }
11237 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11238 result = ((arg1)->m_height);
11239 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj = 0;
11248 wxRect2D *arg1 = (wxRect2D *) 0 ;
11249 wxDouble arg2 = (wxDouble) 0 ;
11250 wxDouble arg3 = (wxDouble) 0 ;
11251 wxDouble arg4 = (wxDouble) 0 ;
11252 wxDouble arg5 = (wxDouble) 0 ;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 void *argp2 ;
11256 int res2 = 0 ;
11257 void *argp3 ;
11258 int res3 = 0 ;
11259 void *argp4 ;
11260 int res4 = 0 ;
11261 void *argp5 ;
11262 int res5 = 0 ;
11263 PyObject * obj0 = 0 ;
11264 PyObject * obj1 = 0 ;
11265 PyObject * obj2 = 0 ;
11266 PyObject * obj3 = 0 ;
11267 PyObject * obj4 = 0 ;
11268 char * kwnames[] = {
11269 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11270 };
11271
11272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11274 if (!SWIG_IsOK(res1)) {
11275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11276 }
11277 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11278 if (obj1) {
11279 {
11280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11281 if (!SWIG_IsOK(res2)) {
11282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11283 }
11284 if (!argp2) {
11285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11286 } else {
11287 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11288 arg2 = *temp;
11289 if (SWIG_IsNewObj(res2)) delete temp;
11290 }
11291 }
11292 }
11293 if (obj2) {
11294 {
11295 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11296 if (!SWIG_IsOK(res3)) {
11297 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11298 }
11299 if (!argp3) {
11300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11301 } else {
11302 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11303 arg3 = *temp;
11304 if (SWIG_IsNewObj(res3)) delete temp;
11305 }
11306 }
11307 }
11308 if (obj3) {
11309 {
11310 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11311 if (!SWIG_IsOK(res4)) {
11312 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11313 }
11314 if (!argp4) {
11315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11316 } else {
11317 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11318 arg4 = *temp;
11319 if (SWIG_IsNewObj(res4)) delete temp;
11320 }
11321 }
11322 }
11323 if (obj4) {
11324 {
11325 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11326 if (!SWIG_IsOK(res5)) {
11327 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11328 }
11329 if (!argp5) {
11330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11331 } else {
11332 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11333 arg5 = *temp;
11334 if (SWIG_IsNewObj(res5)) delete temp;
11335 }
11336 }
11337 }
11338 {
11339 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 resultobj = SWIG_Py_Void();
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11350 PyObject *resultobj = 0;
11351 wxRect2D *arg1 = (wxRect2D *) 0 ;
11352 PyObject *result = 0 ;
11353 void *argp1 = 0 ;
11354 int res1 = 0 ;
11355 PyObject *swig_obj[1] ;
11356
11357 if (!args) SWIG_fail;
11358 swig_obj[0] = args;
11359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11360 if (!SWIG_IsOK(res1)) {
11361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11362 }
11363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11364 {
11365 result = (PyObject *)wxRect2D_Get(arg1);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 resultobj = result;
11369 return resultobj;
11370 fail:
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11376 PyObject *obj;
11377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11378 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11379 return SWIG_Py_Void();
11380 }
11381
11382 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11383 return SWIG_Python_InitShadowInstance(args);
11384 }
11385
11386 SWIGINTERN int DefaultPosition_set(PyObject *) {
11387 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11388 return 1;
11389 }
11390
11391
11392 SWIGINTERN PyObject *DefaultPosition_get(void) {
11393 PyObject *pyobj = 0;
11394
11395 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11396 return pyobj;
11397 }
11398
11399
11400 SWIGINTERN int DefaultSize_set(PyObject *) {
11401 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11402 return 1;
11403 }
11404
11405
11406 SWIGINTERN PyObject *DefaultSize_get(void) {
11407 PyObject *pyobj = 0;
11408
11409 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11410 return pyobj;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj = 0;
11416 PyObject *arg1 = (PyObject *) 0 ;
11417 wxPyInputStream *result = 0 ;
11418 PyObject * obj0 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "p", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11424 arg1 = obj0;
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11439 PyObject *resultobj = 0;
11440 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 PyObject *swig_obj[1] ;
11444
11445 if (!args) SWIG_fail;
11446 swig_obj[0] = args;
11447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11448 if (!SWIG_IsOK(res1)) {
11449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11450 }
11451 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 delete arg1;
11455
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_Py_Void();
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11467 PyObject *resultobj = 0;
11468 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11469 void *argp1 = 0 ;
11470 int res1 = 0 ;
11471 PyObject *swig_obj[1] ;
11472
11473 if (!args) SWIG_fail;
11474 swig_obj[0] = args;
11475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11476 if (!SWIG_IsOK(res1)) {
11477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11478 }
11479 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 (arg1)->close();
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 resultobj = SWIG_Py_Void();
11487 return resultobj;
11488 fail:
11489 return NULL;
11490 }
11491
11492
11493 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11494 PyObject *resultobj = 0;
11495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11496 void *argp1 = 0 ;
11497 int res1 = 0 ;
11498 PyObject *swig_obj[1] ;
11499
11500 if (!args) SWIG_fail;
11501 swig_obj[0] = args;
11502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11503 if (!SWIG_IsOK(res1)) {
11504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11505 }
11506 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11507 {
11508 PyThreadState* __tstate = wxPyBeginAllowThreads();
11509 (arg1)->flush();
11510 wxPyEndAllowThreads(__tstate);
11511 if (PyErr_Occurred()) SWIG_fail;
11512 }
11513 resultobj = SWIG_Py_Void();
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11521 PyObject *resultobj = 0;
11522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11523 bool result;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 PyObject *swig_obj[1] ;
11527
11528 if (!args) SWIG_fail;
11529 swig_obj[0] = args;
11530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11533 }
11534 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)(arg1)->eof();
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 {
11542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11543 }
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj = 0;
11552 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11553 int arg2 = (int) -1 ;
11554 PyObject *result = 0 ;
11555 void *argp1 = 0 ;
11556 int res1 = 0 ;
11557 int val2 ;
11558 int ecode2 = 0 ;
11559 PyObject * obj0 = 0 ;
11560 PyObject * obj1 = 0 ;
11561 char * kwnames[] = {
11562 (char *) "self",(char *) "size", NULL
11563 };
11564
11565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11567 if (!SWIG_IsOK(res1)) {
11568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11569 }
11570 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11571 if (obj1) {
11572 ecode2 = SWIG_AsVal_int(obj1, &val2);
11573 if (!SWIG_IsOK(ecode2)) {
11574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11575 }
11576 arg2 = static_cast< int >(val2);
11577 }
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 result = (PyObject *)(arg1)->read(arg2);
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 resultobj = result;
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj = 0;
11593 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11594 int arg2 = (int) -1 ;
11595 PyObject *result = 0 ;
11596 void *argp1 = 0 ;
11597 int res1 = 0 ;
11598 int val2 ;
11599 int ecode2 = 0 ;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 char * kwnames[] = {
11603 (char *) "self",(char *) "size", NULL
11604 };
11605
11606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11608 if (!SWIG_IsOK(res1)) {
11609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11610 }
11611 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11612 if (obj1) {
11613 ecode2 = SWIG_AsVal_int(obj1, &val2);
11614 if (!SWIG_IsOK(ecode2)) {
11615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11616 }
11617 arg2 = static_cast< int >(val2);
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (PyObject *)(arg1)->readline(arg2);
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 resultobj = result;
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj = 0;
11634 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11635 int arg2 = (int) -1 ;
11636 PyObject *result = 0 ;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 int val2 ;
11640 int ecode2 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "sizehint", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11651 }
11652 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11653 if (obj1) {
11654 ecode2 = SWIG_AsVal_int(obj1, &val2);
11655 if (!SWIG_IsOK(ecode2)) {
11656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11657 }
11658 arg2 = static_cast< int >(val2);
11659 }
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (PyObject *)(arg1)->readlines(arg2);
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 resultobj = result;
11667 return resultobj;
11668 fail:
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11676 int arg2 ;
11677 int arg3 = (int) 0 ;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 int val2 ;
11681 int ecode2 = 0 ;
11682 int val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "offset",(char *) "whence", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11697 ecode2 = SWIG_AsVal_int(obj1, &val2);
11698 if (!SWIG_IsOK(ecode2)) {
11699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11700 }
11701 arg2 = static_cast< int >(val2);
11702 if (obj2) {
11703 ecode3 = SWIG_AsVal_int(obj2, &val3);
11704 if (!SWIG_IsOK(ecode3)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11706 }
11707 arg3 = static_cast< int >(val3);
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 (arg1)->seek(arg2,arg3);
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_Py_Void();
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11725 int result;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11735 }
11736 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (int)(arg1)->tell();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_From_int(static_cast< int >(result));
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11753 char result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject *swig_obj[1] ;
11757
11758 if (!args) SWIG_fail;
11759 swig_obj[0] = args;
11760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11763 }
11764 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (char)(arg1)->Peek();
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 resultobj = SWIG_From_char(static_cast< char >(result));
11772 return resultobj;
11773 fail:
11774 return NULL;
11775 }
11776
11777
11778 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11779 PyObject *resultobj = 0;
11780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11781 char result;
11782 void *argp1 = 0 ;
11783 int res1 = 0 ;
11784 PyObject *swig_obj[1] ;
11785
11786 if (!args) SWIG_fail;
11787 swig_obj[0] = args;
11788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11789 if (!SWIG_IsOK(res1)) {
11790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11791 }
11792 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (char)(arg1)->GetC();
11796 wxPyEndAllowThreads(__tstate);
11797 if (PyErr_Occurred()) SWIG_fail;
11798 }
11799 resultobj = SWIG_From_char(static_cast< char >(result));
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11809 size_t result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11819 }
11820 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (size_t)(arg1)->LastRead();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11837 bool result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11847 }
11848 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (bool)(arg1)->CanRead();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11867 bool result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11877 }
11878 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (bool)(arg1)->Eof();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj = 0;
11896 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11897 char arg2 ;
11898 bool result;
11899 void *argp1 = 0 ;
11900 int res1 = 0 ;
11901 char val2 ;
11902 int ecode2 = 0 ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 char * kwnames[] = {
11906 (char *) "self",(char *) "c", NULL
11907 };
11908
11909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11911 if (!SWIG_IsOK(res1)) {
11912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11913 }
11914 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11915 ecode2 = SWIG_AsVal_char(obj1, &val2);
11916 if (!SWIG_IsOK(ecode2)) {
11917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11918 }
11919 arg2 = static_cast< char >(val2);
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (bool)(arg1)->Ungetch(arg2);
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj = 0;
11937 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11938 long arg2 ;
11939 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11940 long result;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 long val2 ;
11944 int ecode2 = 0 ;
11945 int val3 ;
11946 int ecode3 = 0 ;
11947 PyObject * obj0 = 0 ;
11948 PyObject * obj1 = 0 ;
11949 PyObject * obj2 = 0 ;
11950 char * kwnames[] = {
11951 (char *) "self",(char *) "pos",(char *) "mode", NULL
11952 };
11953
11954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11956 if (!SWIG_IsOK(res1)) {
11957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11958 }
11959 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11960 ecode2 = SWIG_AsVal_long(obj1, &val2);
11961 if (!SWIG_IsOK(ecode2)) {
11962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11963 }
11964 arg2 = static_cast< long >(val2);
11965 if (obj2) {
11966 ecode3 = SWIG_AsVal_int(obj2, &val3);
11967 if (!SWIG_IsOK(ecode3)) {
11968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11969 }
11970 arg3 = static_cast< wxSeekMode >(val3);
11971 }
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (long)(arg1)->SeekI(arg2,arg3);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 resultobj = SWIG_From_long(static_cast< long >(result));
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 PyObject *resultobj = 0;
11987 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11988 long result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 PyObject *swig_obj[1] ;
11992
11993 if (!args) SWIG_fail;
11994 swig_obj[0] = args;
11995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11996 if (!SWIG_IsOK(res1)) {
11997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11998 }
11999 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (long)(arg1)->TellI();
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 resultobj = SWIG_From_long(static_cast< long >(result));
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12014 PyObject *obj;
12015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12016 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12017 return SWIG_Py_Void();
12018 }
12019
12020 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12021 return SWIG_Python_InitShadowInstance(args);
12022 }
12023
12024 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj = 0;
12026 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12027 PyObject *arg2 = (PyObject *) 0 ;
12028 void *argp1 = 0 ;
12029 int res1 = 0 ;
12030 PyObject * obj0 = 0 ;
12031 PyObject * obj1 = 0 ;
12032 char * kwnames[] = {
12033 (char *) "self",(char *) "obj", NULL
12034 };
12035
12036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12038 if (!SWIG_IsOK(res1)) {
12039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12040 }
12041 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12042 arg2 = obj1;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 wxOutputStream_write(arg1,arg2);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_Py_Void();
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 PyObject *resultobj = 0;
12058 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12059 size_t result;
12060 void *argp1 = 0 ;
12061 int res1 = 0 ;
12062 PyObject *swig_obj[1] ;
12063
12064 if (!args) SWIG_fail;
12065 swig_obj[0] = args;
12066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12069 }
12070 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *obj;
12086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12087 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12088 return SWIG_Py_Void();
12089 }
12090
12091 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj = 0;
12093 wxInputStream *arg1 = (wxInputStream *) 0 ;
12094 wxString *arg2 = 0 ;
12095 wxString *arg3 = 0 ;
12096 wxString *arg4 = 0 ;
12097 wxDateTime arg5 ;
12098 wxFSFile *result = 0 ;
12099 wxPyInputStream *temp1 ;
12100 bool temp2 = false ;
12101 bool temp3 = false ;
12102 bool temp4 = false ;
12103 void *argp5 ;
12104 int res5 = 0 ;
12105 PyObject * obj0 = 0 ;
12106 PyObject * obj1 = 0 ;
12107 PyObject * obj2 = 0 ;
12108 PyObject * obj3 = 0 ;
12109 PyObject * obj4 = 0 ;
12110 char * kwnames[] = {
12111 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12112 };
12113
12114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12115 {
12116 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12117 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12118 } else {
12119 PyErr_Clear(); // clear the failure of the wxPyConvert above
12120 arg1 = wxPyCBInputStream_create(obj0, true);
12121 if (arg1 == NULL) {
12122 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12123 SWIG_fail;
12124 }
12125 }
12126 }
12127 {
12128 arg2 = wxString_in_helper(obj1);
12129 if (arg2 == NULL) SWIG_fail;
12130 temp2 = true;
12131 }
12132 {
12133 arg3 = wxString_in_helper(obj2);
12134 if (arg3 == NULL) SWIG_fail;
12135 temp3 = true;
12136 }
12137 {
12138 arg4 = wxString_in_helper(obj3);
12139 if (arg4 == NULL) SWIG_fail;
12140 temp4 = true;
12141 }
12142 {
12143 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12144 if (!SWIG_IsOK(res5)) {
12145 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12146 }
12147 if (!argp5) {
12148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12149 } else {
12150 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12151 arg5 = *temp;
12152 if (SWIG_IsNewObj(res5)) delete temp;
12153 }
12154 }
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12162 {
12163 if (temp2)
12164 delete arg2;
12165 }
12166 {
12167 if (temp3)
12168 delete arg3;
12169 }
12170 {
12171 if (temp4)
12172 delete arg4;
12173 }
12174 return resultobj;
12175 fail:
12176 {
12177 if (temp2)
12178 delete arg2;
12179 }
12180 {
12181 if (temp3)
12182 delete arg3;
12183 }
12184 {
12185 if (temp4)
12186 delete arg4;
12187 }
12188 return NULL;
12189 }
12190
12191
12192 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12193 PyObject *resultobj = 0;
12194 wxFSFile *arg1 = (wxFSFile *) 0 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 PyObject *swig_obj[1] ;
12198
12199 if (!args) SWIG_fail;
12200 swig_obj[0] = args;
12201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12202 if (!SWIG_IsOK(res1)) {
12203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12204 }
12205 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 delete arg1;
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 resultobj = SWIG_Py_Void();
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12221 PyObject *resultobj = 0;
12222 wxFSFile *arg1 = (wxFSFile *) 0 ;
12223 wxInputStream *result = 0 ;
12224 void *argp1 = 0 ;
12225 int res1 = 0 ;
12226 PyObject *swig_obj[1] ;
12227
12228 if (!args) SWIG_fail;
12229 swig_obj[0] = args;
12230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12233 }
12234 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = (wxInputStream *)(arg1)->GetStream();
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 {
12242 wxPyInputStream * _ptr = NULL;
12243
12244 if (result) {
12245 _ptr = new wxPyInputStream(result);
12246 }
12247 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12256 PyObject *resultobj = 0;
12257 wxFSFile *arg1 = (wxFSFile *) 0 ;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 PyObject *swig_obj[1] ;
12261
12262 if (!args) SWIG_fail;
12263 swig_obj[0] = args;
12264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12265 if (!SWIG_IsOK(res1)) {
12266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12267 }
12268 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 (arg1)->DetachStream();
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_Py_Void();
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12283 PyObject *resultobj = 0;
12284 wxFSFile *arg1 = (wxFSFile *) 0 ;
12285 wxString *result = 0 ;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 PyObject *swig_obj[1] ;
12289
12290 if (!args) SWIG_fail;
12291 swig_obj[0] = args;
12292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12293 if (!SWIG_IsOK(res1)) {
12294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12295 }
12296 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 {
12300 wxString const &_result_ref = (arg1)->GetMimeType();
12301 result = (wxString *) &_result_ref;
12302 }
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 #if wxUSE_UNICODE
12308 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12309 #else
12310 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12311 #endif
12312 }
12313 return resultobj;
12314 fail:
12315 return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *resultobj = 0;
12321 wxFSFile *arg1 = (wxFSFile *) 0 ;
12322 wxString *result = 0 ;
12323 void *argp1 = 0 ;
12324 int res1 = 0 ;
12325 PyObject *swig_obj[1] ;
12326
12327 if (!args) SWIG_fail;
12328 swig_obj[0] = args;
12329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12332 }
12333 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 {
12337 wxString const &_result_ref = (arg1)->GetLocation();
12338 result = (wxString *) &_result_ref;
12339 }
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 {
12344 #if wxUSE_UNICODE
12345 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12346 #else
12347 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12348 #endif
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *resultobj = 0;
12358 wxFSFile *arg1 = (wxFSFile *) 0 ;
12359 wxString *result = 0 ;
12360 void *argp1 = 0 ;
12361 int res1 = 0 ;
12362 PyObject *swig_obj[1] ;
12363
12364 if (!args) SWIG_fail;
12365 swig_obj[0] = args;
12366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12367 if (!SWIG_IsOK(res1)) {
12368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12369 }
12370 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 {
12374 wxString const &_result_ref = (arg1)->GetAnchor();
12375 result = (wxString *) &_result_ref;
12376 }
12377 wxPyEndAllowThreads(__tstate);
12378 if (PyErr_Occurred()) SWIG_fail;
12379 }
12380 {
12381 #if wxUSE_UNICODE
12382 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12383 #else
12384 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12385 #endif
12386 }
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12394 PyObject *resultobj = 0;
12395 wxFSFile *arg1 = (wxFSFile *) 0 ;
12396 wxDateTime result;
12397 void *argp1 = 0 ;
12398 int res1 = 0 ;
12399 PyObject *swig_obj[1] ;
12400
12401 if (!args) SWIG_fail;
12402 swig_obj[0] = args;
12403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12404 if (!SWIG_IsOK(res1)) {
12405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12406 }
12407 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = (arg1)->GetModificationTime();
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12415 return resultobj;
12416 fail:
12417 return NULL;
12418 }
12419
12420
12421 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12422 PyObject *obj;
12423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12424 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12425 return SWIG_Py_Void();
12426 }
12427
12428 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 return SWIG_Python_InitShadowInstance(args);
12430 }
12431
12432 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12433 PyObject *resultobj = 0;
12434 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12435 void *argp1 = 0 ;
12436 int res1 = 0 ;
12437 PyObject *swig_obj[1] ;
12438
12439 if (!args) SWIG_fail;
12440 swig_obj[0] = args;
12441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12442 if (!SWIG_IsOK(res1)) {
12443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12444 }
12445 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 delete arg1;
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 resultobj = SWIG_Py_Void();
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461 PyObject *obj;
12462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12463 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12464 return SWIG_Py_Void();
12465 }
12466
12467 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 PyObject *resultobj = 0;
12469 wxPyFileSystemHandler *result = 0 ;
12470
12471 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj = 0;
12487 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12488 PyObject *arg2 = (PyObject *) 0 ;
12489 PyObject *arg3 = (PyObject *) 0 ;
12490 void *argp1 = 0 ;
12491 int res1 = 0 ;
12492 PyObject * obj0 = 0 ;
12493 PyObject * obj1 = 0 ;
12494 PyObject * obj2 = 0 ;
12495 char * kwnames[] = {
12496 (char *) "self",(char *) "self",(char *) "_class", NULL
12497 };
12498
12499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12501 if (!SWIG_IsOK(res1)) {
12502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12503 }
12504 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12505 arg2 = obj1;
12506 arg3 = obj2;
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 (arg1)->_setCallbackInfo(arg2,arg3);
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_Py_Void();
12514 return resultobj;
12515 fail:
12516 return NULL;
12517 }
12518
12519
12520 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12523 wxString *arg2 = 0 ;
12524 bool result;
12525 void *argp1 = 0 ;
12526 int res1 = 0 ;
12527 bool temp2 = false ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char * kwnames[] = {
12531 (char *) "self",(char *) "location", NULL
12532 };
12533
12534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12538 }
12539 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12540 {
12541 arg2 = wxString_in_helper(obj1);
12542 if (arg2 == NULL) SWIG_fail;
12543 temp2 = true;
12544 }
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12553 }
12554 {
12555 if (temp2)
12556 delete arg2;
12557 }
12558 return resultobj;
12559 fail:
12560 {
12561 if (temp2)
12562 delete arg2;
12563 }
12564 return NULL;
12565 }
12566
12567
12568 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12569 PyObject *resultobj = 0;
12570 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12571 wxFileSystem *arg2 = 0 ;
12572 wxString *arg3 = 0 ;
12573 wxFSFile *result = 0 ;
12574 void *argp1 = 0 ;
12575 int res1 = 0 ;
12576 void *argp2 = 0 ;
12577 int res2 = 0 ;
12578 bool temp3 = false ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 PyObject * obj2 = 0 ;
12582 char * kwnames[] = {
12583 (char *) "self",(char *) "fs",(char *) "location", NULL
12584 };
12585
12586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12588 if (!SWIG_IsOK(res1)) {
12589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12590 }
12591 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12592 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12593 if (!SWIG_IsOK(res2)) {
12594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12595 }
12596 if (!argp2) {
12597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12598 }
12599 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12600 {
12601 arg3 = wxString_in_helper(obj2);
12602 if (arg3 == NULL) SWIG_fail;
12603 temp3 = true;
12604 }
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12613 }
12614 {
12615 if (temp3)
12616 delete arg3;
12617 }
12618 return resultobj;
12619 fail:
12620 {
12621 if (temp3)
12622 delete arg3;
12623 }
12624 return NULL;
12625 }
12626
12627
12628 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj = 0;
12630 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12631 wxString *arg2 = 0 ;
12632 int arg3 = (int) 0 ;
12633 wxString result;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 bool temp2 = false ;
12637 int val3 ;
12638 int ecode3 = 0 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 char * kwnames[] = {
12643 (char *) "self",(char *) "spec",(char *) "flags", NULL
12644 };
12645
12646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12648 if (!SWIG_IsOK(res1)) {
12649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12650 }
12651 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12652 {
12653 arg2 = wxString_in_helper(obj1);
12654 if (arg2 == NULL) SWIG_fail;
12655 temp2 = true;
12656 }
12657 if (obj2) {
12658 ecode3 = SWIG_AsVal_int(obj2, &val3);
12659 if (!SWIG_IsOK(ecode3)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12661 }
12662 arg3 = static_cast< int >(val3);
12663 }
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 #if wxUSE_UNICODE
12672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12673 #else
12674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12675 #endif
12676 }
12677 {
12678 if (temp2)
12679 delete arg2;
12680 }
12681 return resultobj;
12682 fail:
12683 {
12684 if (temp2)
12685 delete arg2;
12686 }
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12692 PyObject *resultobj = 0;
12693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12694 wxString result;
12695 void *argp1 = 0 ;
12696 int res1 = 0 ;
12697 PyObject *swig_obj[1] ;
12698
12699 if (!args) SWIG_fail;
12700 swig_obj[0] = args;
12701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12702 if (!SWIG_IsOK(res1)) {
12703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12704 }
12705 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (arg1)->FindNext();
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 #if wxUSE_UNICODE
12714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12715 #else
12716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12717 #endif
12718 }
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12726 PyObject *resultobj = 0;
12727 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12728 wxString *arg2 = 0 ;
12729 wxString result;
12730 void *argp1 = 0 ;
12731 int res1 = 0 ;
12732 bool temp2 = false ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char * kwnames[] = {
12736 (char *) "self",(char *) "location", NULL
12737 };
12738
12739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12743 }
12744 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12745 {
12746 arg2 = wxString_in_helper(obj1);
12747 if (arg2 == NULL) SWIG_fail;
12748 temp2 = true;
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (arg1)->GetProtocol((wxString const &)*arg2);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 #if wxUSE_UNICODE
12758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12759 #else
12760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12761 #endif
12762 }
12763 {
12764 if (temp2)
12765 delete arg2;
12766 }
12767 return resultobj;
12768 fail:
12769 {
12770 if (temp2)
12771 delete arg2;
12772 }
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj = 0;
12779 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12780 wxString *arg2 = 0 ;
12781 wxString result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 bool temp2 = false ;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 char * kwnames[] = {
12788 (char *) "self",(char *) "location", NULL
12789 };
12790
12791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12793 if (!SWIG_IsOK(res1)) {
12794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12795 }
12796 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12797 {
12798 arg2 = wxString_in_helper(obj1);
12799 if (arg2 == NULL) SWIG_fail;
12800 temp2 = true;
12801 }
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 {
12809 #if wxUSE_UNICODE
12810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12811 #else
12812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12813 #endif
12814 }
12815 {
12816 if (temp2)
12817 delete arg2;
12818 }
12819 return resultobj;
12820 fail:
12821 {
12822 if (temp2)
12823 delete arg2;
12824 }
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12830 PyObject *resultobj = 0;
12831 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12832 wxString *arg2 = 0 ;
12833 wxString result;
12834 void *argp1 = 0 ;
12835 int res1 = 0 ;
12836 bool temp2 = false ;
12837 PyObject * obj0 = 0 ;
12838 PyObject * obj1 = 0 ;
12839 char * kwnames[] = {
12840 (char *) "self",(char *) "location", NULL
12841 };
12842
12843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12845 if (!SWIG_IsOK(res1)) {
12846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12847 }
12848 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12849 {
12850 arg2 = wxString_in_helper(obj1);
12851 if (arg2 == NULL) SWIG_fail;
12852 temp2 = true;
12853 }
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 result = (arg1)->GetAnchor((wxString const &)*arg2);
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 #if wxUSE_UNICODE
12862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12863 #else
12864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12865 #endif
12866 }
12867 {
12868 if (temp2)
12869 delete arg2;
12870 }
12871 return resultobj;
12872 fail:
12873 {
12874 if (temp2)
12875 delete arg2;
12876 }
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12882 PyObject *resultobj = 0;
12883 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12884 wxString *arg2 = 0 ;
12885 wxString result;
12886 void *argp1 = 0 ;
12887 int res1 = 0 ;
12888 bool temp2 = false ;
12889 PyObject * obj0 = 0 ;
12890 PyObject * obj1 = 0 ;
12891 char * kwnames[] = {
12892 (char *) "self",(char *) "location", NULL
12893 };
12894
12895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12897 if (!SWIG_IsOK(res1)) {
12898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12899 }
12900 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12901 {
12902 arg2 = wxString_in_helper(obj1);
12903 if (arg2 == NULL) SWIG_fail;
12904 temp2 = true;
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 {
12913 #if wxUSE_UNICODE
12914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12915 #else
12916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12917 #endif
12918 }
12919 {
12920 if (temp2)
12921 delete arg2;
12922 }
12923 return resultobj;
12924 fail:
12925 {
12926 if (temp2)
12927 delete arg2;
12928 }
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj = 0;
12935 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12936 wxString *arg2 = 0 ;
12937 wxString result;
12938 void *argp1 = 0 ;
12939 int res1 = 0 ;
12940 bool temp2 = false ;
12941 PyObject * obj0 = 0 ;
12942 PyObject * obj1 = 0 ;
12943 char * kwnames[] = {
12944 (char *) "self",(char *) "location", NULL
12945 };
12946
12947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12951 }
12952 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12953 {
12954 arg2 = wxString_in_helper(obj1);
12955 if (arg2 == NULL) SWIG_fail;
12956 temp2 = true;
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 {
12965 #if wxUSE_UNICODE
12966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12967 #else
12968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12969 #endif
12970 }
12971 {
12972 if (temp2)
12973 delete arg2;
12974 }
12975 return resultobj;
12976 fail:
12977 {
12978 if (temp2)
12979 delete arg2;
12980 }
12981 return NULL;
12982 }
12983
12984
12985 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12986 PyObject *obj;
12987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12989 return SWIG_Py_Void();
12990 }
12991
12992 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 return SWIG_Python_InitShadowInstance(args);
12994 }
12995
12996 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *resultobj = 0;
12998 wxFileSystem *result = 0 ;
12999
13000 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 result = (wxFileSystem *)new wxFileSystem();
13004 wxPyEndAllowThreads(__tstate);
13005 if (PyErr_Occurred()) SWIG_fail;
13006 }
13007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *resultobj = 0;
13016 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13017 void *argp1 = 0 ;
13018 int res1 = 0 ;
13019 PyObject *swig_obj[1] ;
13020
13021 if (!args) SWIG_fail;
13022 swig_obj[0] = args;
13023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13024 if (!SWIG_IsOK(res1)) {
13025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13026 }
13027 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13028 {
13029 PyThreadState* __tstate = wxPyBeginAllowThreads();
13030 delete arg1;
13031
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 resultobj = SWIG_Py_Void();
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj = 0;
13044 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13045 wxString *arg2 = 0 ;
13046 bool arg3 = (bool) false ;
13047 void *argp1 = 0 ;
13048 int res1 = 0 ;
13049 bool temp2 = false ;
13050 bool val3 ;
13051 int ecode3 = 0 ;
13052 PyObject * obj0 = 0 ;
13053 PyObject * obj1 = 0 ;
13054 PyObject * obj2 = 0 ;
13055 char * kwnames[] = {
13056 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13057 };
13058
13059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13061 if (!SWIG_IsOK(res1)) {
13062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13063 }
13064 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13065 {
13066 arg2 = wxString_in_helper(obj1);
13067 if (arg2 == NULL) SWIG_fail;
13068 temp2 = true;
13069 }
13070 if (obj2) {
13071 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13072 if (!SWIG_IsOK(ecode3)) {
13073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13074 }
13075 arg3 = static_cast< bool >(val3);
13076 }
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13080 wxPyEndAllowThreads(__tstate);
13081 if (PyErr_Occurred()) SWIG_fail;
13082 }
13083 resultobj = SWIG_Py_Void();
13084 {
13085 if (temp2)
13086 delete arg2;
13087 }
13088 return resultobj;
13089 fail:
13090 {
13091 if (temp2)
13092 delete arg2;
13093 }
13094 return NULL;
13095 }
13096
13097
13098 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *resultobj = 0;
13100 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13101 wxString result;
13102 void *argp1 = 0 ;
13103 int res1 = 0 ;
13104 PyObject *swig_obj[1] ;
13105
13106 if (!args) SWIG_fail;
13107 swig_obj[0] = args;
13108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13109 if (!SWIG_IsOK(res1)) {
13110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13111 }
13112 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = (arg1)->GetPath();
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 {
13120 #if wxUSE_UNICODE
13121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13122 #else
13123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13124 #endif
13125 }
13126 return resultobj;
13127 fail:
13128 return NULL;
13129 }
13130
13131
13132 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13133 PyObject *resultobj = 0;
13134 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13135 wxString *arg2 = 0 ;
13136 wxFSFile *result = 0 ;
13137 void *argp1 = 0 ;
13138 int res1 = 0 ;
13139 bool temp2 = false ;
13140 PyObject * obj0 = 0 ;
13141 PyObject * obj1 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "self",(char *) "location", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13150 }
13151 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13152 {
13153 arg2 = wxString_in_helper(obj1);
13154 if (arg2 == NULL) SWIG_fail;
13155 temp2 = true;
13156 }
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 {
13164 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13165 }
13166 {
13167 if (temp2)
13168 delete arg2;
13169 }
13170 return resultobj;
13171 fail:
13172 {
13173 if (temp2)
13174 delete arg2;
13175 }
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13183 wxString *arg2 = 0 ;
13184 int arg3 = (int) 0 ;
13185 wxString result;
13186 void *argp1 = 0 ;
13187 int res1 = 0 ;
13188 bool temp2 = false ;
13189 int val3 ;
13190 int ecode3 = 0 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 PyObject * obj2 = 0 ;
13194 char * kwnames[] = {
13195 (char *) "self",(char *) "spec",(char *) "flags", NULL
13196 };
13197
13198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13200 if (!SWIG_IsOK(res1)) {
13201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13202 }
13203 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13204 {
13205 arg2 = wxString_in_helper(obj1);
13206 if (arg2 == NULL) SWIG_fail;
13207 temp2 = true;
13208 }
13209 if (obj2) {
13210 ecode3 = SWIG_AsVal_int(obj2, &val3);
13211 if (!SWIG_IsOK(ecode3)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13213 }
13214 arg3 = static_cast< int >(val3);
13215 }
13216 {
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 {
13223 #if wxUSE_UNICODE
13224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13225 #else
13226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13227 #endif
13228 }
13229 {
13230 if (temp2)
13231 delete arg2;
13232 }
13233 return resultobj;
13234 fail:
13235 {
13236 if (temp2)
13237 delete arg2;
13238 }
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13244 PyObject *resultobj = 0;
13245 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13246 wxString result;
13247 void *argp1 = 0 ;
13248 int res1 = 0 ;
13249 PyObject *swig_obj[1] ;
13250
13251 if (!args) SWIG_fail;
13252 swig_obj[0] = args;
13253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13254 if (!SWIG_IsOK(res1)) {
13255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13256 }
13257 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = (arg1)->FindNext();
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 {
13265 #if wxUSE_UNICODE
13266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13267 #else
13268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13269 #endif
13270 }
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj = 0;
13279 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13280 int res1 = 0 ;
13281 PyObject * obj0 = 0 ;
13282 char * kwnames[] = {
13283 (char *) "handler", NULL
13284 };
13285
13286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13287 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13288 if (!SWIG_IsOK(res1)) {
13289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13290 }
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 wxFileSystem::AddHandler(arg1);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_Py_Void();
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13307 wxFileSystemHandler *result = 0 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 PyObject * obj0 = 0 ;
13311 char * kwnames[] = {
13312 (char *) "handler", NULL
13313 };
13314
13315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13317 if (!SWIG_IsOK(res1)) {
13318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13319 }
13320 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13335 PyObject *resultobj = 0;
13336
13337 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 wxFileSystem::CleanUpHandlers();
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_Py_Void();
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = 0;
13353 wxString *arg1 = 0 ;
13354 wxString result;
13355 bool temp1 = false ;
13356 PyObject * obj0 = 0 ;
13357 char * kwnames[] = {
13358 (char *) "filename", NULL
13359 };
13360
13361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13362 {
13363 arg1 = wxString_in_helper(obj0);
13364 if (arg1 == NULL) SWIG_fail;
13365 temp1 = true;
13366 }
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 {
13374 #if wxUSE_UNICODE
13375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13376 #else
13377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13378 #endif
13379 }
13380 {
13381 if (temp1)
13382 delete arg1;
13383 }
13384 return resultobj;
13385 fail:
13386 {
13387 if (temp1)
13388 delete arg1;
13389 }
13390 return NULL;
13391 }
13392
13393
13394 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13395 PyObject *resultobj = 0;
13396 wxString *arg1 = 0 ;
13397 wxString result;
13398 bool temp1 = false ;
13399 PyObject * obj0 = 0 ;
13400 char * kwnames[] = {
13401 (char *) "url", NULL
13402 };
13403
13404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13405 {
13406 arg1 = wxString_in_helper(obj0);
13407 if (arg1 == NULL) SWIG_fail;
13408 temp1 = true;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 #if wxUSE_UNICODE
13418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13419 #else
13420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13421 #endif
13422 }
13423 {
13424 if (temp1)
13425 delete arg1;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp1)
13431 delete arg1;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *obj;
13439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13440 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13441 return SWIG_Py_Void();
13442 }
13443
13444 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 return SWIG_Python_InitShadowInstance(args);
13446 }
13447
13448 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *resultobj = 0;
13450 wxInternetFSHandler *result = 0 ;
13451
13452 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj = 0;
13468 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13469 wxString *arg2 = 0 ;
13470 bool result;
13471 void *argp1 = 0 ;
13472 int res1 = 0 ;
13473 bool temp2 = false ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 char * kwnames[] = {
13477 (char *) "self",(char *) "location", NULL
13478 };
13479
13480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13482 if (!SWIG_IsOK(res1)) {
13483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13484 }
13485 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13486 {
13487 arg2 = wxString_in_helper(obj1);
13488 if (arg2 == NULL) SWIG_fail;
13489 temp2 = true;
13490 }
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 {
13501 if (temp2)
13502 delete arg2;
13503 }
13504 return resultobj;
13505 fail:
13506 {
13507 if (temp2)
13508 delete arg2;
13509 }
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj = 0;
13516 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13517 wxFileSystem *arg2 = 0 ;
13518 wxString *arg3 = 0 ;
13519 wxFSFile *result = 0 ;
13520 void *argp1 = 0 ;
13521 int res1 = 0 ;
13522 void *argp2 = 0 ;
13523 int res2 = 0 ;
13524 bool temp3 = false ;
13525 PyObject * obj0 = 0 ;
13526 PyObject * obj1 = 0 ;
13527 PyObject * obj2 = 0 ;
13528 char * kwnames[] = {
13529 (char *) "self",(char *) "fs",(char *) "location", NULL
13530 };
13531
13532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13534 if (!SWIG_IsOK(res1)) {
13535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13536 }
13537 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13539 if (!SWIG_IsOK(res2)) {
13540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13541 }
13542 if (!argp2) {
13543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13544 }
13545 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13546 {
13547 arg3 = wxString_in_helper(obj2);
13548 if (arg3 == NULL) SWIG_fail;
13549 temp3 = true;
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 {
13558 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13559 }
13560 {
13561 if (temp3)
13562 delete arg3;
13563 }
13564 return resultobj;
13565 fail:
13566 {
13567 if (temp3)
13568 delete arg3;
13569 }
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13575 PyObject *obj;
13576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13577 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13578 return SWIG_Py_Void();
13579 }
13580
13581 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13582 return SWIG_Python_InitShadowInstance(args);
13583 }
13584
13585 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586 PyObject *resultobj = 0;
13587 wxZipFSHandler *result = 0 ;
13588
13589 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13590 {
13591 PyThreadState* __tstate = wxPyBeginAllowThreads();
13592 result = (wxZipFSHandler *)new wxZipFSHandler();
13593 wxPyEndAllowThreads(__tstate);
13594 if (PyErr_Occurred()) SWIG_fail;
13595 }
13596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = 0;
13605 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13606 wxString *arg2 = 0 ;
13607 bool result;
13608 void *argp1 = 0 ;
13609 int res1 = 0 ;
13610 bool temp2 = false ;
13611 PyObject * obj0 = 0 ;
13612 PyObject * obj1 = 0 ;
13613 char * kwnames[] = {
13614 (char *) "self",(char *) "location", NULL
13615 };
13616
13617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13619 if (!SWIG_IsOK(res1)) {
13620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13621 }
13622 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13623 {
13624 arg2 = wxString_in_helper(obj1);
13625 if (arg2 == NULL) SWIG_fail;
13626 temp2 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 {
13635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13636 }
13637 {
13638 if (temp2)
13639 delete arg2;
13640 }
13641 return resultobj;
13642 fail:
13643 {
13644 if (temp2)
13645 delete arg2;
13646 }
13647 return NULL;
13648 }
13649
13650
13651 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj = 0;
13653 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13654 wxFileSystem *arg2 = 0 ;
13655 wxString *arg3 = 0 ;
13656 wxFSFile *result = 0 ;
13657 void *argp1 = 0 ;
13658 int res1 = 0 ;
13659 void *argp2 = 0 ;
13660 int res2 = 0 ;
13661 bool temp3 = false ;
13662 PyObject * obj0 = 0 ;
13663 PyObject * obj1 = 0 ;
13664 PyObject * obj2 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "self",(char *) "fs",(char *) "location", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13673 }
13674 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13675 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13676 if (!SWIG_IsOK(res2)) {
13677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13678 }
13679 if (!argp2) {
13680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13681 }
13682 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13683 {
13684 arg3 = wxString_in_helper(obj2);
13685 if (arg3 == NULL) SWIG_fail;
13686 temp3 = true;
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13691 wxPyEndAllowThreads(__tstate);
13692 if (PyErr_Occurred()) SWIG_fail;
13693 }
13694 {
13695 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13696 }
13697 {
13698 if (temp3)
13699 delete arg3;
13700 }
13701 return resultobj;
13702 fail:
13703 {
13704 if (temp3)
13705 delete arg3;
13706 }
13707 return NULL;
13708 }
13709
13710
13711 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj = 0;
13713 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13714 wxString *arg2 = 0 ;
13715 int arg3 = (int) 0 ;
13716 wxString result;
13717 void *argp1 = 0 ;
13718 int res1 = 0 ;
13719 bool temp2 = false ;
13720 int val3 ;
13721 int ecode3 = 0 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "self",(char *) "spec",(char *) "flags", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13731 if (!SWIG_IsOK(res1)) {
13732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13733 }
13734 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13735 {
13736 arg2 = wxString_in_helper(obj1);
13737 if (arg2 == NULL) SWIG_fail;
13738 temp2 = true;
13739 }
13740 if (obj2) {
13741 ecode3 = SWIG_AsVal_int(obj2, &val3);
13742 if (!SWIG_IsOK(ecode3)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13744 }
13745 arg3 = static_cast< int >(val3);
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 {
13754 #if wxUSE_UNICODE
13755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13756 #else
13757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13758 #endif
13759 }
13760 {
13761 if (temp2)
13762 delete arg2;
13763 }
13764 return resultobj;
13765 fail:
13766 {
13767 if (temp2)
13768 delete arg2;
13769 }
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775 PyObject *resultobj = 0;
13776 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13777 wxString result;
13778 void *argp1 = 0 ;
13779 int res1 = 0 ;
13780 PyObject *swig_obj[1] ;
13781
13782 if (!args) SWIG_fail;
13783 swig_obj[0] = args;
13784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13787 }
13788 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 result = (arg1)->FindNext();
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 {
13796 #if wxUSE_UNICODE
13797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13798 #else
13799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13800 #endif
13801 }
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13809 PyObject *obj;
13810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13811 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13812 return SWIG_Py_Void();
13813 }
13814
13815 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13816 return SWIG_Python_InitShadowInstance(args);
13817 }
13818
13819 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13820 PyObject *resultobj = 0;
13821 wxString *arg1 = 0 ;
13822 wxImage *arg2 = 0 ;
13823 long arg3 ;
13824 bool temp1 = false ;
13825 void *argp2 = 0 ;
13826 int res2 = 0 ;
13827 long val3 ;
13828 int ecode3 = 0 ;
13829 PyObject * obj0 = 0 ;
13830 PyObject * obj1 = 0 ;
13831 PyObject * obj2 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "filename",(char *) "image",(char *) "type", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13837 {
13838 arg1 = wxString_in_helper(obj0);
13839 if (arg1 == NULL) SWIG_fail;
13840 temp1 = true;
13841 }
13842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13843 if (!SWIG_IsOK(res2)) {
13844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13845 }
13846 if (!argp2) {
13847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13848 }
13849 arg2 = reinterpret_cast< wxImage * >(argp2);
13850 ecode3 = SWIG_AsVal_long(obj2, &val3);
13851 if (!SWIG_IsOK(ecode3)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13853 }
13854 arg3 = static_cast< long >(val3);
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 resultobj = SWIG_Py_Void();
13862 {
13863 if (temp1)
13864 delete arg1;
13865 }
13866 return resultobj;
13867 fail:
13868 {
13869 if (temp1)
13870 delete arg1;
13871 }
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxString *arg1 = 0 ;
13879 wxBitmap *arg2 = 0 ;
13880 long arg3 ;
13881 bool temp1 = false ;
13882 void *argp2 = 0 ;
13883 int res2 = 0 ;
13884 long val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 {
13895 arg1 = wxString_in_helper(obj0);
13896 if (arg1 == NULL) SWIG_fail;
13897 temp1 = true;
13898 }
13899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13900 if (!SWIG_IsOK(res2)) {
13901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13902 }
13903 if (!argp2) {
13904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13905 }
13906 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13907 ecode3 = SWIG_AsVal_long(obj2, &val3);
13908 if (!SWIG_IsOK(ecode3)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13910 }
13911 arg3 = static_cast< long >(val3);
13912 {
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 resultobj = SWIG_Py_Void();
13919 {
13920 if (temp1)
13921 delete arg1;
13922 }
13923 return resultobj;
13924 fail:
13925 {
13926 if (temp1)
13927 delete arg1;
13928 }
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13934 PyObject *resultobj = 0;
13935 wxString *arg1 = 0 ;
13936 PyObject *arg2 = (PyObject *) 0 ;
13937 bool temp1 = false ;
13938 PyObject * obj0 = 0 ;
13939 PyObject * obj1 = 0 ;
13940 char * kwnames[] = {
13941 (char *) "filename",(char *) "data", NULL
13942 };
13943
13944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13945 {
13946 arg1 = wxString_in_helper(obj0);
13947 if (arg1 == NULL) SWIG_fail;
13948 temp1 = true;
13949 }
13950 arg2 = obj1;
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13954 wxPyEndAllowThreads(__tstate);
13955 if (PyErr_Occurred()) SWIG_fail;
13956 }
13957 resultobj = SWIG_Py_Void();
13958 {
13959 if (temp1)
13960 delete arg1;
13961 }
13962 return resultobj;
13963 fail:
13964 {
13965 if (temp1)
13966 delete arg1;
13967 }
13968 return NULL;
13969 }
13970
13971
13972 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13973 PyObject *resultobj = 0;
13974 wxMemoryFSHandler *result = 0 ;
13975
13976 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13984 return resultobj;
13985 fail:
13986 return NULL;
13987 }
13988
13989
13990 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13991 PyObject *resultobj = 0;
13992 wxString *arg1 = 0 ;
13993 bool temp1 = false ;
13994 PyObject * obj0 = 0 ;
13995 char * kwnames[] = {
13996 (char *) "filename", NULL
13997 };
13998
13999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14000 {
14001 arg1 = wxString_in_helper(obj0);
14002 if (arg1 == NULL) SWIG_fail;
14003 temp1 = true;
14004 }
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 return resultobj;
14017 fail:
14018 {
14019 if (temp1)
14020 delete arg1;
14021 }
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14029 wxString *arg2 = 0 ;
14030 bool result;
14031 void *argp1 = 0 ;
14032 int res1 = 0 ;
14033 bool temp2 = false ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 char * kwnames[] = {
14037 (char *) "self",(char *) "location", NULL
14038 };
14039
14040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14042 if (!SWIG_IsOK(res1)) {
14043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14044 }
14045 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14046 {
14047 arg2 = wxString_in_helper(obj1);
14048 if (arg2 == NULL) SWIG_fail;
14049 temp2 = true;
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14059 }
14060 {
14061 if (temp2)
14062 delete arg2;
14063 }
14064 return resultobj;
14065 fail:
14066 {
14067 if (temp2)
14068 delete arg2;
14069 }
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14077 wxFileSystem *arg2 = 0 ;
14078 wxString *arg3 = 0 ;
14079 wxFSFile *result = 0 ;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 void *argp2 = 0 ;
14083 int res2 = 0 ;
14084 bool temp3 = false ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 PyObject * obj2 = 0 ;
14088 char * kwnames[] = {
14089 (char *) "self",(char *) "fs",(char *) "location", NULL
14090 };
14091
14092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14094 if (!SWIG_IsOK(res1)) {
14095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14096 }
14097 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14099 if (!SWIG_IsOK(res2)) {
14100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14101 }
14102 if (!argp2) {
14103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14104 }
14105 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14106 {
14107 arg3 = wxString_in_helper(obj2);
14108 if (arg3 == NULL) SWIG_fail;
14109 temp3 = true;
14110 }
14111 {
14112 PyThreadState* __tstate = wxPyBeginAllowThreads();
14113 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 {
14118 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14119 }
14120 {
14121 if (temp3)
14122 delete arg3;
14123 }
14124 return resultobj;
14125 fail:
14126 {
14127 if (temp3)
14128 delete arg3;
14129 }
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14137 wxString *arg2 = 0 ;
14138 int arg3 = (int) 0 ;
14139 wxString result;
14140 void *argp1 = 0 ;
14141 int res1 = 0 ;
14142 bool temp2 = false ;
14143 int val3 ;
14144 int ecode3 = 0 ;
14145 PyObject * obj0 = 0 ;
14146 PyObject * obj1 = 0 ;
14147 PyObject * obj2 = 0 ;
14148 char * kwnames[] = {
14149 (char *) "self",(char *) "spec",(char *) "flags", NULL
14150 };
14151
14152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14154 if (!SWIG_IsOK(res1)) {
14155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14156 }
14157 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14158 {
14159 arg2 = wxString_in_helper(obj1);
14160 if (arg2 == NULL) SWIG_fail;
14161 temp2 = true;
14162 }
14163 if (obj2) {
14164 ecode3 = SWIG_AsVal_int(obj2, &val3);
14165 if (!SWIG_IsOK(ecode3)) {
14166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14167 }
14168 arg3 = static_cast< int >(val3);
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 {
14177 #if wxUSE_UNICODE
14178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14179 #else
14180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14181 #endif
14182 }
14183 {
14184 if (temp2)
14185 delete arg2;
14186 }
14187 return resultobj;
14188 fail:
14189 {
14190 if (temp2)
14191 delete arg2;
14192 }
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14198 PyObject *resultobj = 0;
14199 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14200 wxString result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 PyObject *swig_obj[1] ;
14204
14205 if (!args) SWIG_fail;
14206 swig_obj[0] = args;
14207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14208 if (!SWIG_IsOK(res1)) {
14209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14210 }
14211 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 result = (arg1)->FindNext();
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 #if wxUSE_UNICODE
14220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14221 #else
14222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14223 #endif
14224 }
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 PyObject *obj;
14233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14234 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14235 return SWIG_Py_Void();
14236 }
14237
14238 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 return SWIG_Python_InitShadowInstance(args);
14240 }
14241
14242 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *resultobj = 0;
14244 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14245 wxString result;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 PyObject *swig_obj[1] ;
14249
14250 if (!args) SWIG_fail;
14251 swig_obj[0] = args;
14252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14253 if (!SWIG_IsOK(res1)) {
14254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14255 }
14256 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (arg1)->GetName();
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 #if wxUSE_UNICODE
14265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14266 #else
14267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14268 #endif
14269 }
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14277 PyObject *resultobj = 0;
14278 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14279 wxString result;
14280 void *argp1 = 0 ;
14281 int res1 = 0 ;
14282 PyObject *swig_obj[1] ;
14283
14284 if (!args) SWIG_fail;
14285 swig_obj[0] = args;
14286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14287 if (!SWIG_IsOK(res1)) {
14288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14289 }
14290 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (arg1)->GetExtension();
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 {
14298 #if wxUSE_UNICODE
14299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14300 #else
14301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14302 #endif
14303 }
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14311 PyObject *resultobj = 0;
14312 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14313 long result;
14314 void *argp1 = 0 ;
14315 int res1 = 0 ;
14316 PyObject *swig_obj[1] ;
14317
14318 if (!args) SWIG_fail;
14319 swig_obj[0] = args;
14320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14321 if (!SWIG_IsOK(res1)) {
14322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14323 }
14324 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (long)(arg1)->GetType();
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_From_long(static_cast< long >(result));
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14339 PyObject *resultobj = 0;
14340 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14341 wxString result;
14342 void *argp1 = 0 ;
14343 int res1 = 0 ;
14344 PyObject *swig_obj[1] ;
14345
14346 if (!args) SWIG_fail;
14347 swig_obj[0] = args;
14348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14349 if (!SWIG_IsOK(res1)) {
14350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14351 }
14352 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (arg1)->GetMimeType();
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 {
14360 #if wxUSE_UNICODE
14361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14362 #else
14363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14364 #endif
14365 }
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj = 0;
14374 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14375 wxString *arg2 = 0 ;
14376 bool result;
14377 void *argp1 = 0 ;
14378 int res1 = 0 ;
14379 bool temp2 = false ;
14380 PyObject * obj0 = 0 ;
14381 PyObject * obj1 = 0 ;
14382 char * kwnames[] = {
14383 (char *) "self",(char *) "name", NULL
14384 };
14385
14386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14388 if (!SWIG_IsOK(res1)) {
14389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14390 }
14391 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14392 {
14393 arg2 = wxString_in_helper(obj1);
14394 if (arg2 == NULL) SWIG_fail;
14395 temp2 = true;
14396 }
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14405 }
14406 {
14407 if (temp2)
14408 delete arg2;
14409 }
14410 return resultobj;
14411 fail:
14412 {
14413 if (temp2)
14414 delete arg2;
14415 }
14416 return NULL;
14417 }
14418
14419
14420 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14421 PyObject *resultobj = 0;
14422 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14423 wxInputStream *arg2 = 0 ;
14424 bool result;
14425 void *argp1 = 0 ;
14426 int res1 = 0 ;
14427 wxPyInputStream *temp2 ;
14428 bool created2 ;
14429 PyObject * obj0 = 0 ;
14430 PyObject * obj1 = 0 ;
14431 char * kwnames[] = {
14432 (char *) "self",(char *) "stream", NULL
14433 };
14434
14435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14437 if (!SWIG_IsOK(res1)) {
14438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14439 }
14440 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14441 {
14442 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14443 arg2 = temp2->m_wxis;
14444 created2 = false;
14445 } else {
14446 PyErr_Clear(); // clear the failure of the wxPyConvert above
14447 arg2 = wxPyCBInputStream_create(obj1, false);
14448 if (arg2 == NULL) {
14449 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14450 SWIG_fail;
14451 }
14452 created2 = true;
14453 }
14454 }
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 result = (bool)(arg1)->CanRead(*arg2);
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 {
14462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14463 }
14464 {
14465 if (created2) delete arg2;
14466 }
14467 return resultobj;
14468 fail:
14469 {
14470 if (created2) delete arg2;
14471 }
14472 return NULL;
14473 }
14474
14475
14476 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj = 0;
14478 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14479 wxString *arg2 = 0 ;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 bool temp2 = false ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "name", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14495 {
14496 arg2 = wxString_in_helper(obj1);
14497 if (arg2 == NULL) SWIG_fail;
14498 temp2 = true;
14499 }
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 (arg1)->SetName((wxString const &)*arg2);
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 resultobj = SWIG_Py_Void();
14507 {
14508 if (temp2)
14509 delete arg2;
14510 }
14511 return resultobj;
14512 fail:
14513 {
14514 if (temp2)
14515 delete arg2;
14516 }
14517 return NULL;
14518 }
14519
14520
14521 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14522 PyObject *resultobj = 0;
14523 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14524 wxString *arg2 = 0 ;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 bool temp2 = false ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 char * kwnames[] = {
14531 (char *) "self",(char *) "extension", NULL
14532 };
14533
14534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14536 if (!SWIG_IsOK(res1)) {
14537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14538 }
14539 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14540 {
14541 arg2 = wxString_in_helper(obj1);
14542 if (arg2 == NULL) SWIG_fail;
14543 temp2 = true;
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 (arg1)->SetExtension((wxString const &)*arg2);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_Py_Void();
14552 {
14553 if (temp2)
14554 delete arg2;
14555 }
14556 return resultobj;
14557 fail:
14558 {
14559 if (temp2)
14560 delete arg2;
14561 }
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj = 0;
14568 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14569 long arg2 ;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 long val2 ;
14573 int ecode2 = 0 ;
14574 PyObject * obj0 = 0 ;
14575 PyObject * obj1 = 0 ;
14576 char * kwnames[] = {
14577 (char *) "self",(char *) "type", NULL
14578 };
14579
14580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14582 if (!SWIG_IsOK(res1)) {
14583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14584 }
14585 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14586 ecode2 = SWIG_AsVal_long(obj1, &val2);
14587 if (!SWIG_IsOK(ecode2)) {
14588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14589 }
14590 arg2 = static_cast< long >(val2);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 (arg1)->SetType(arg2);
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 resultobj = SWIG_Py_Void();
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj = 0;
14606 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14607 wxString *arg2 = 0 ;
14608 void *argp1 = 0 ;
14609 int res1 = 0 ;
14610 bool temp2 = false ;
14611 PyObject * obj0 = 0 ;
14612 PyObject * obj1 = 0 ;
14613 char * kwnames[] = {
14614 (char *) "self",(char *) "mimetype", NULL
14615 };
14616
14617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14621 }
14622 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14623 {
14624 arg2 = wxString_in_helper(obj1);
14625 if (arg2 == NULL) SWIG_fail;
14626 temp2 = true;
14627 }
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 (arg1)->SetMimeType((wxString const &)*arg2);
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_Py_Void();
14635 {
14636 if (temp2)
14637 delete arg2;
14638 }
14639 return resultobj;
14640 fail:
14641 {
14642 if (temp2)
14643 delete arg2;
14644 }
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14650 PyObject *obj;
14651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14652 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14653 return SWIG_Py_Void();
14654 }
14655
14656 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657 PyObject *resultobj = 0;
14658 wxPyImageHandler *result = 0 ;
14659
14660 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (wxPyImageHandler *)new wxPyImageHandler();
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj = 0;
14676 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14677 PyObject *arg2 = (PyObject *) 0 ;
14678 void *argp1 = 0 ;
14679 int res1 = 0 ;
14680 PyObject * obj0 = 0 ;
14681 PyObject * obj1 = 0 ;
14682 char * kwnames[] = {
14683 (char *) "self",(char *) "self", NULL
14684 };
14685
14686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14690 }
14691 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14692 arg2 = obj1;
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 (arg1)->_SetSelf(arg2);
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 resultobj = SWIG_Py_Void();
14700 return resultobj;
14701 fail:
14702 return NULL;
14703 }
14704
14705
14706 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14707 PyObject *obj;
14708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14709 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14710 return SWIG_Py_Void();
14711 }
14712
14713 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14714 return SWIG_Python_InitShadowInstance(args);
14715 }
14716
14717 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *resultobj = 0;
14719 wxImageHistogram *result = 0 ;
14720
14721 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (wxImageHistogram *)new wxImageHistogram();
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 byte arg1 ;
14738 byte arg2 ;
14739 byte arg3 ;
14740 unsigned long result;
14741 unsigned char val1 ;
14742 int ecode1 = 0 ;
14743 unsigned char val2 ;
14744 int ecode2 = 0 ;
14745 unsigned char val3 ;
14746 int ecode3 = 0 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 char * kwnames[] = {
14751 (char *) "r",(char *) "g",(char *) "b", NULL
14752 };
14753
14754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14755 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14756 if (!SWIG_IsOK(ecode1)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14758 }
14759 arg1 = static_cast< byte >(val1);
14760 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14761 if (!SWIG_IsOK(ecode2)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14763 }
14764 arg2 = static_cast< byte >(val2);
14765 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14766 if (!SWIG_IsOK(ecode3)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14768 }
14769 arg3 = static_cast< byte >(val3);
14770 {
14771 PyThreadState* __tstate = wxPyBeginAllowThreads();
14772 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14784 PyObject *resultobj = 0;
14785 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14786 byte *arg2 = (byte *) 0 ;
14787 byte *arg3 = (byte *) 0 ;
14788 byte *arg4 = (byte *) 0 ;
14789 byte arg5 = (byte) 1 ;
14790 byte arg6 = (byte) 0 ;
14791 byte arg7 = (byte) 0 ;
14792 bool result;
14793 void *argp1 = 0 ;
14794 int res1 = 0 ;
14795 byte temp2 ;
14796 int res2 = SWIG_TMPOBJ ;
14797 byte temp3 ;
14798 int res3 = SWIG_TMPOBJ ;
14799 byte temp4 ;
14800 int res4 = SWIG_TMPOBJ ;
14801 unsigned char val5 ;
14802 int ecode5 = 0 ;
14803 unsigned char val6 ;
14804 int ecode6 = 0 ;
14805 unsigned char val7 ;
14806 int ecode7 = 0 ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 PyObject * obj3 = 0 ;
14811 char * kwnames[] = {
14812 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14813 };
14814
14815 arg2 = &temp2;
14816 arg3 = &temp3;
14817 arg4 = &temp4;
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14824 if (obj1) {
14825 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14826 if (!SWIG_IsOK(ecode5)) {
14827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14828 }
14829 arg5 = static_cast< byte >(val5);
14830 }
14831 if (obj2) {
14832 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14833 if (!SWIG_IsOK(ecode6)) {
14834 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14835 }
14836 arg6 = static_cast< byte >(val6);
14837 }
14838 if (obj3) {
14839 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14840 if (!SWIG_IsOK(ecode7)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14842 }
14843 arg7 = static_cast< byte >(val7);
14844 }
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 if (SWIG_IsTmpObj(res2)) {
14855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14856 } else {
14857 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14859 }
14860 if (SWIG_IsTmpObj(res3)) {
14861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14862 } else {
14863 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14865 }
14866 if (SWIG_IsTmpObj(res4)) {
14867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14868 } else {
14869 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14871 }
14872 return resultobj;
14873 fail:
14874 return NULL;
14875 }
14876
14877
14878 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj = 0;
14880 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14881 unsigned long arg2 ;
14882 unsigned long result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 unsigned long val2 ;
14886 int ecode2 = 0 ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "self",(char *) "key", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14899 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14900 if (!SWIG_IsOK(ecode2)) {
14901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14902 }
14903 arg2 = static_cast< unsigned long >(val2);
14904 {
14905 PyThreadState* __tstate = wxPyBeginAllowThreads();
14906 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj = 0;
14919 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14920 byte arg2 ;
14921 byte arg3 ;
14922 byte arg4 ;
14923 unsigned long result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 unsigned char val2 ;
14927 int ecode2 = 0 ;
14928 unsigned char val3 ;
14929 int ecode3 = 0 ;
14930 unsigned char val4 ;
14931 int ecode4 = 0 ;
14932 PyObject * obj0 = 0 ;
14933 PyObject * obj1 = 0 ;
14934 PyObject * obj2 = 0 ;
14935 PyObject * obj3 = 0 ;
14936 char * kwnames[] = {
14937 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14938 };
14939
14940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14944 }
14945 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14946 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14947 if (!SWIG_IsOK(ecode2)) {
14948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14949 }
14950 arg2 = static_cast< byte >(val2);
14951 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14952 if (!SWIG_IsOK(ecode3)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14954 }
14955 arg3 = static_cast< byte >(val3);
14956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14957 if (!SWIG_IsOK(ecode4)) {
14958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14959 }
14960 arg4 = static_cast< byte >(val4);
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14977 wxColour *arg2 = 0 ;
14978 unsigned long result;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 wxColour temp2 ;
14982 PyObject * obj0 = 0 ;
14983 PyObject * obj1 = 0 ;
14984 char * kwnames[] = {
14985 (char *) "self",(char *) "colour", NULL
14986 };
14987
14988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14990 if (!SWIG_IsOK(res1)) {
14991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14992 }
14993 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14994 {
14995 arg2 = &temp2;
14996 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14997 }
14998 {
14999 PyThreadState* __tstate = wxPyBeginAllowThreads();
15000 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15001 wxPyEndAllowThreads(__tstate);
15002 if (PyErr_Occurred()) SWIG_fail;
15003 }
15004 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15005 return resultobj;
15006 fail:
15007 return NULL;
15008 }
15009
15010
15011 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15012 PyObject *obj;
15013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15014 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15015 return SWIG_Py_Void();
15016 }
15017
15018 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15019 return SWIG_Python_InitShadowInstance(args);
15020 }
15021
15022 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj = 0;
15024 byte arg1 = (byte) 0 ;
15025 byte arg2 = (byte) 0 ;
15026 byte arg3 = (byte) 0 ;
15027 wxImage_RGBValue *result = 0 ;
15028 unsigned char val1 ;
15029 int ecode1 = 0 ;
15030 unsigned char val2 ;
15031 int ecode2 = 0 ;
15032 unsigned char val3 ;
15033 int ecode3 = 0 ;
15034 PyObject * obj0 = 0 ;
15035 PyObject * obj1 = 0 ;
15036 PyObject * obj2 = 0 ;
15037 char * kwnames[] = {
15038 (char *) "r",(char *) "g",(char *) "b", NULL
15039 };
15040
15041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15042 if (obj0) {
15043 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15044 if (!SWIG_IsOK(ecode1)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15046 }
15047 arg1 = static_cast< byte >(val1);
15048 }
15049 if (obj1) {
15050 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15051 if (!SWIG_IsOK(ecode2)) {
15052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15053 }
15054 arg2 = static_cast< byte >(val2);
15055 }
15056 if (obj2) {
15057 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15058 if (!SWIG_IsOK(ecode3)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15060 }
15061 arg3 = static_cast< byte >(val3);
15062 }
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *resultobj = 0;
15078 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15079 byte arg2 ;
15080 void *argp1 = 0 ;
15081 int res1 = 0 ;
15082 unsigned char val2 ;
15083 int ecode2 = 0 ;
15084 PyObject *swig_obj[2] ;
15085
15086 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15088 if (!SWIG_IsOK(res1)) {
15089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15090 }
15091 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15092 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15093 if (!SWIG_IsOK(ecode2)) {
15094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15095 }
15096 arg2 = static_cast< byte >(val2);
15097 if (arg1) (arg1)->red = arg2;
15098
15099 resultobj = SWIG_Py_Void();
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15107 PyObject *resultobj = 0;
15108 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15109 byte result;
15110 void *argp1 = 0 ;
15111 int res1 = 0 ;
15112 PyObject *swig_obj[1] ;
15113
15114 if (!args) SWIG_fail;
15115 swig_obj[0] = args;
15116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15117 if (!SWIG_IsOK(res1)) {
15118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15119 }
15120 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15121 result = (byte) ((arg1)->red);
15122 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15123 return resultobj;
15124 fail:
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15130 PyObject *resultobj = 0;
15131 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15132 byte arg2 ;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 unsigned char val2 ;
15136 int ecode2 = 0 ;
15137 PyObject *swig_obj[2] ;
15138
15139 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15141 if (!SWIG_IsOK(res1)) {
15142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15143 }
15144 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15145 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15146 if (!SWIG_IsOK(ecode2)) {
15147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15148 }
15149 arg2 = static_cast< byte >(val2);
15150 if (arg1) (arg1)->green = arg2;
15151
15152 resultobj = SWIG_Py_Void();
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15162 byte result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15172 }
15173 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15174 result = (byte) ((arg1)->green);
15175 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15183 PyObject *resultobj = 0;
15184 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15185 byte arg2 ;
15186 void *argp1 = 0 ;
15187 int res1 = 0 ;
15188 unsigned char val2 ;
15189 int ecode2 = 0 ;
15190 PyObject *swig_obj[2] ;
15191
15192 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15194 if (!SWIG_IsOK(res1)) {
15195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15196 }
15197 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15198 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15199 if (!SWIG_IsOK(ecode2)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15201 }
15202 arg2 = static_cast< byte >(val2);
15203 if (arg1) (arg1)->blue = arg2;
15204
15205 resultobj = SWIG_Py_Void();
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15213 PyObject *resultobj = 0;
15214 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15215 byte result;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 PyObject *swig_obj[1] ;
15219
15220 if (!args) SWIG_fail;
15221 swig_obj[0] = args;
15222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15223 if (!SWIG_IsOK(res1)) {
15224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15225 }
15226 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15227 result = (byte) ((arg1)->blue);
15228 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15236 PyObject *obj;
15237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15238 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15239 return SWIG_Py_Void();
15240 }
15241
15242 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15243 return SWIG_Python_InitShadowInstance(args);
15244 }
15245
15246 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj = 0;
15248 double arg1 = (double) 0.0 ;
15249 double arg2 = (double) 0.0 ;
15250 double arg3 = (double) 0.0 ;
15251 wxImage_HSVValue *result = 0 ;
15252 double val1 ;
15253 int ecode1 = 0 ;
15254 double val2 ;
15255 int ecode2 = 0 ;
15256 double val3 ;
15257 int ecode3 = 0 ;
15258 PyObject * obj0 = 0 ;
15259 PyObject * obj1 = 0 ;
15260 PyObject * obj2 = 0 ;
15261 char * kwnames[] = {
15262 (char *) "h",(char *) "s",(char *) "v", NULL
15263 };
15264
15265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15266 if (obj0) {
15267 ecode1 = SWIG_AsVal_double(obj0, &val1);
15268 if (!SWIG_IsOK(ecode1)) {
15269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15270 }
15271 arg1 = static_cast< double >(val1);
15272 }
15273 if (obj1) {
15274 ecode2 = SWIG_AsVal_double(obj1, &val2);
15275 if (!SWIG_IsOK(ecode2)) {
15276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15277 }
15278 arg2 = static_cast< double >(val2);
15279 }
15280 if (obj2) {
15281 ecode3 = SWIG_AsVal_double(obj2, &val3);
15282 if (!SWIG_IsOK(ecode3)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15284 }
15285 arg3 = static_cast< double >(val3);
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15303 double arg2 ;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 double val2 ;
15307 int ecode2 = 0 ;
15308 PyObject *swig_obj[2] ;
15309
15310 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15316 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15317 if (!SWIG_IsOK(ecode2)) {
15318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15319 }
15320 arg2 = static_cast< double >(val2);
15321 if (arg1) (arg1)->hue = arg2;
15322
15323 resultobj = SWIG_Py_Void();
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *resultobj = 0;
15332 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15333 double result;
15334 void *argp1 = 0 ;
15335 int res1 = 0 ;
15336 PyObject *swig_obj[1] ;
15337
15338 if (!args) SWIG_fail;
15339 swig_obj[0] = args;
15340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15341 if (!SWIG_IsOK(res1)) {
15342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15343 }
15344 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15345 result = (double) ((arg1)->hue);
15346 resultobj = SWIG_From_double(static_cast< double >(result));
15347 return resultobj;
15348 fail:
15349 return NULL;
15350 }
15351
15352
15353 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15354 PyObject *resultobj = 0;
15355 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15356 double arg2 ;
15357 void *argp1 = 0 ;
15358 int res1 = 0 ;
15359 double val2 ;
15360 int ecode2 = 0 ;
15361 PyObject *swig_obj[2] ;
15362
15363 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15367 }
15368 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15369 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15370 if (!SWIG_IsOK(ecode2)) {
15371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15372 }
15373 arg2 = static_cast< double >(val2);
15374 if (arg1) (arg1)->saturation = arg2;
15375
15376 resultobj = SWIG_Py_Void();
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15386 double result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15398 result = (double) ((arg1)->saturation);
15399 resultobj = SWIG_From_double(static_cast< double >(result));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15407 PyObject *resultobj = 0;
15408 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15409 double arg2 ;
15410 void *argp1 = 0 ;
15411 int res1 = 0 ;
15412 double val2 ;
15413 int ecode2 = 0 ;
15414 PyObject *swig_obj[2] ;
15415
15416 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15418 if (!SWIG_IsOK(res1)) {
15419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15420 }
15421 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15422 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15423 if (!SWIG_IsOK(ecode2)) {
15424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15425 }
15426 arg2 = static_cast< double >(val2);
15427 if (arg1) (arg1)->value = arg2;
15428
15429 resultobj = SWIG_Py_Void();
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15439 double result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15451 result = (double) ((arg1)->value);
15452 resultobj = SWIG_From_double(static_cast< double >(result));
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *obj;
15461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15462 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15463 return SWIG_Py_Void();
15464 }
15465
15466 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15467 return SWIG_Python_InitShadowInstance(args);
15468 }
15469
15470 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj = 0;
15472 wxString *arg1 = 0 ;
15473 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15474 int arg3 = (int) -1 ;
15475 wxImage *result = 0 ;
15476 bool temp1 = false ;
15477 long val2 ;
15478 int ecode2 = 0 ;
15479 int val3 ;
15480 int ecode3 = 0 ;
15481 PyObject * obj0 = 0 ;
15482 PyObject * obj1 = 0 ;
15483 PyObject * obj2 = 0 ;
15484 char * kwnames[] = {
15485 (char *) "name",(char *) "type",(char *) "index", NULL
15486 };
15487
15488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15489 {
15490 arg1 = wxString_in_helper(obj0);
15491 if (arg1 == NULL) SWIG_fail;
15492 temp1 = true;
15493 }
15494 if (obj1) {
15495 ecode2 = SWIG_AsVal_long(obj1, &val2);
15496 if (!SWIG_IsOK(ecode2)) {
15497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15498 }
15499 arg2 = static_cast< long >(val2);
15500 }
15501 if (obj2) {
15502 ecode3 = SWIG_AsVal_int(obj2, &val3);
15503 if (!SWIG_IsOK(ecode3)) {
15504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15505 }
15506 arg3 = static_cast< int >(val3);
15507 }
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15515 {
15516 if (temp1)
15517 delete arg1;
15518 }
15519 return resultobj;
15520 fail:
15521 {
15522 if (temp1)
15523 delete arg1;
15524 }
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15530 PyObject *resultobj = 0;
15531 wxImage *arg1 = (wxImage *) 0 ;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 PyObject *swig_obj[1] ;
15535
15536 if (!args) SWIG_fail;
15537 swig_obj[0] = args;
15538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15541 }
15542 arg1 = reinterpret_cast< wxImage * >(argp1);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 delete arg1;
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = SWIG_Py_Void();
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj = 0;
15559 wxString *arg1 = 0 ;
15560 wxString *arg2 = 0 ;
15561 int arg3 = (int) -1 ;
15562 wxImage *result = 0 ;
15563 bool temp1 = false ;
15564 bool temp2 = false ;
15565 int val3 ;
15566 int ecode3 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 PyObject * obj2 = 0 ;
15570 char * kwnames[] = {
15571 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15572 };
15573
15574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15575 {
15576 arg1 = wxString_in_helper(obj0);
15577 if (arg1 == NULL) SWIG_fail;
15578 temp1 = true;
15579 }
15580 {
15581 arg2 = wxString_in_helper(obj1);
15582 if (arg2 == NULL) SWIG_fail;
15583 temp2 = true;
15584 }
15585 if (obj2) {
15586 ecode3 = SWIG_AsVal_int(obj2, &val3);
15587 if (!SWIG_IsOK(ecode3)) {
15588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15589 }
15590 arg3 = static_cast< int >(val3);
15591 }
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15599 {
15600 if (temp1)
15601 delete arg1;
15602 }
15603 {
15604 if (temp2)
15605 delete arg2;
15606 }
15607 return resultobj;
15608 fail:
15609 {
15610 if (temp1)
15611 delete arg1;
15612 }
15613 {
15614 if (temp2)
15615 delete arg2;
15616 }
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj = 0;
15623 wxInputStream *arg1 = 0 ;
15624 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15625 int arg3 = (int) -1 ;
15626 wxImage *result = 0 ;
15627 wxPyInputStream *temp1 ;
15628 bool created1 ;
15629 long val2 ;
15630 int ecode2 = 0 ;
15631 int val3 ;
15632 int ecode3 = 0 ;
15633 PyObject * obj0 = 0 ;
15634 PyObject * obj1 = 0 ;
15635 PyObject * obj2 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "stream",(char *) "type",(char *) "index", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15641 {
15642 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15643 arg1 = temp1->m_wxis;
15644 created1 = false;
15645 } else {
15646 PyErr_Clear(); // clear the failure of the wxPyConvert above
15647 arg1 = wxPyCBInputStream_create(obj0, false);
15648 if (arg1 == NULL) {
15649 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15650 SWIG_fail;
15651 }
15652 created1 = true;
15653 }
15654 }
15655 if (obj1) {
15656 ecode2 = SWIG_AsVal_long(obj1, &val2);
15657 if (!SWIG_IsOK(ecode2)) {
15658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15659 }
15660 arg2 = static_cast< long >(val2);
15661 }
15662 if (obj2) {
15663 ecode3 = SWIG_AsVal_int(obj2, &val3);
15664 if (!SWIG_IsOK(ecode3)) {
15665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15666 }
15667 arg3 = static_cast< int >(val3);
15668 }
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15676 {
15677 if (created1) delete arg1;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (created1) delete arg1;
15683 }
15684 return NULL;
15685 }
15686
15687
15688 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15689 PyObject *resultobj = 0;
15690 wxInputStream *arg1 = 0 ;
15691 wxString *arg2 = 0 ;
15692 int arg3 = (int) -1 ;
15693 wxImage *result = 0 ;
15694 wxPyInputStream *temp1 ;
15695 bool created1 ;
15696 bool temp2 = false ;
15697 int val3 ;
15698 int ecode3 = 0 ;
15699 PyObject * obj0 = 0 ;
15700 PyObject * obj1 = 0 ;
15701 PyObject * obj2 = 0 ;
15702 char * kwnames[] = {
15703 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15704 };
15705
15706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15707 {
15708 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15709 arg1 = temp1->m_wxis;
15710 created1 = false;
15711 } else {
15712 PyErr_Clear(); // clear the failure of the wxPyConvert above
15713 arg1 = wxPyCBInputStream_create(obj0, false);
15714 if (arg1 == NULL) {
15715 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15716 SWIG_fail;
15717 }
15718 created1 = true;
15719 }
15720 }
15721 {
15722 arg2 = wxString_in_helper(obj1);
15723 if (arg2 == NULL) SWIG_fail;
15724 temp2 = true;
15725 }
15726 if (obj2) {
15727 ecode3 = SWIG_AsVal_int(obj2, &val3);
15728 if (!SWIG_IsOK(ecode3)) {
15729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15730 }
15731 arg3 = static_cast< int >(val3);
15732 }
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15740 {
15741 if (created1) delete arg1;
15742 }
15743 {
15744 if (temp2)
15745 delete arg2;
15746 }
15747 return resultobj;
15748 fail:
15749 {
15750 if (created1) delete arg1;
15751 }
15752 {
15753 if (temp2)
15754 delete arg2;
15755 }
15756 return NULL;
15757 }
15758
15759
15760 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15761 PyObject *resultobj = 0;
15762 int arg1 = (int) 0 ;
15763 int arg2 = (int) 0 ;
15764 bool arg3 = (bool) true ;
15765 wxImage *result = 0 ;
15766 int val1 ;
15767 int ecode1 = 0 ;
15768 int val2 ;
15769 int ecode2 = 0 ;
15770 bool val3 ;
15771 int ecode3 = 0 ;
15772 PyObject * obj0 = 0 ;
15773 PyObject * obj1 = 0 ;
15774 PyObject * obj2 = 0 ;
15775 char * kwnames[] = {
15776 (char *) "width",(char *) "height",(char *) "clear", NULL
15777 };
15778
15779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15780 if (obj0) {
15781 ecode1 = SWIG_AsVal_int(obj0, &val1);
15782 if (!SWIG_IsOK(ecode1)) {
15783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15784 }
15785 arg1 = static_cast< int >(val1);
15786 }
15787 if (obj1) {
15788 ecode2 = SWIG_AsVal_int(obj1, &val2);
15789 if (!SWIG_IsOK(ecode2)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15791 }
15792 arg2 = static_cast< int >(val2);
15793 }
15794 if (obj2) {
15795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15796 if (!SWIG_IsOK(ecode3)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15798 }
15799 arg3 = static_cast< bool >(val3);
15800 }
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj = 0;
15816 wxBitmap *arg1 = 0 ;
15817 wxImage *result = 0 ;
15818 void *argp1 = 0 ;
15819 int res1 = 0 ;
15820 PyObject * obj0 = 0 ;
15821 char * kwnames[] = {
15822 (char *) "bitmap", NULL
15823 };
15824
15825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15826 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15827 if (!SWIG_IsOK(res1)) {
15828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15829 }
15830 if (!argp1) {
15831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15832 }
15833 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15834 {
15835 if (!wxPyCheckForApp()) SWIG_fail;
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 int arg1 ;
15851 int arg2 ;
15852 buffer arg3 ;
15853 int arg4 ;
15854 wxImage *result = 0 ;
15855 int val1 ;
15856 int ecode1 = 0 ;
15857 int val2 ;
15858 int ecode2 = 0 ;
15859 Py_ssize_t temp3 ;
15860 PyObject * obj0 = 0 ;
15861 PyObject * obj1 = 0 ;
15862 PyObject * obj2 = 0 ;
15863 char * kwnames[] = {
15864 (char *) "width",(char *) "height",(char *) "data", NULL
15865 };
15866
15867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15868 ecode1 = SWIG_AsVal_int(obj0, &val1);
15869 if (!SWIG_IsOK(ecode1)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15871 }
15872 arg1 = static_cast< int >(val1);
15873 ecode2 = SWIG_AsVal_int(obj1, &val2);
15874 if (!SWIG_IsOK(ecode2)) {
15875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15876 }
15877 arg2 = static_cast< int >(val2);
15878 {
15879 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15880 arg4 = (int)temp3;
15881 }
15882 {
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj = 0;
15897 int arg1 ;
15898 int arg2 ;
15899 buffer arg3 ;
15900 int arg4 ;
15901 buffer arg5 ;
15902 int arg6 ;
15903 wxImage *result = 0 ;
15904 int val1 ;
15905 int ecode1 = 0 ;
15906 int val2 ;
15907 int ecode2 = 0 ;
15908 Py_ssize_t temp3 ;
15909 Py_ssize_t temp5 ;
15910 PyObject * obj0 = 0 ;
15911 PyObject * obj1 = 0 ;
15912 PyObject * obj2 = 0 ;
15913 PyObject * obj3 = 0 ;
15914 char * kwnames[] = {
15915 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15916 };
15917
15918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15919 ecode1 = SWIG_AsVal_int(obj0, &val1);
15920 if (!SWIG_IsOK(ecode1)) {
15921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15922 }
15923 arg1 = static_cast< int >(val1);
15924 ecode2 = SWIG_AsVal_int(obj1, &val2);
15925 if (!SWIG_IsOK(ecode2)) {
15926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15927 }
15928 arg2 = static_cast< int >(val2);
15929 {
15930 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15931 arg4 = (int)temp3;
15932 }
15933 {
15934 if (obj3 != Py_None) {
15935 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15936 arg6 = (int)temp5;
15937 }
15938 }
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj = 0;
15954 wxImage *arg1 = (wxImage *) 0 ;
15955 int arg2 ;
15956 int arg3 ;
15957 bool arg4 = (bool) true ;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 int val2 ;
15961 int ecode2 = 0 ;
15962 int val3 ;
15963 int ecode3 = 0 ;
15964 bool val4 ;
15965 int ecode4 = 0 ;
15966 PyObject * obj0 = 0 ;
15967 PyObject * obj1 = 0 ;
15968 PyObject * obj2 = 0 ;
15969 PyObject * obj3 = 0 ;
15970 char * kwnames[] = {
15971 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15972 };
15973
15974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15976 if (!SWIG_IsOK(res1)) {
15977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15978 }
15979 arg1 = reinterpret_cast< wxImage * >(argp1);
15980 ecode2 = SWIG_AsVal_int(obj1, &val2);
15981 if (!SWIG_IsOK(ecode2)) {
15982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15983 }
15984 arg2 = static_cast< int >(val2);
15985 ecode3 = SWIG_AsVal_int(obj2, &val3);
15986 if (!SWIG_IsOK(ecode3)) {
15987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15988 }
15989 arg3 = static_cast< int >(val3);
15990 if (obj3) {
15991 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15992 if (!SWIG_IsOK(ecode4)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15994 }
15995 arg4 = static_cast< bool >(val4);
15996 }
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->Create(arg2,arg3,arg4);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16011 PyObject *resultobj = 0;
16012 wxImage *arg1 = (wxImage *) 0 ;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16022 }
16023 arg1 = reinterpret_cast< wxImage * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 (arg1)->Destroy();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_Py_Void();
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj = 0;
16039 wxImage *arg1 = (wxImage *) 0 ;
16040 int arg2 ;
16041 int arg3 ;
16042 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16043 SwigValueWrapper<wxImage > result;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 int val2 ;
16047 int ecode2 = 0 ;
16048 int val3 ;
16049 int ecode3 = 0 ;
16050 int val4 ;
16051 int ecode4 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 PyObject * obj2 = 0 ;
16055 PyObject * obj3 = 0 ;
16056 char * kwnames[] = {
16057 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16058 };
16059
16060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16062 if (!SWIG_IsOK(res1)) {
16063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16064 }
16065 arg1 = reinterpret_cast< wxImage * >(argp1);
16066 ecode2 = SWIG_AsVal_int(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16069 }
16070 arg2 = static_cast< int >(val2);
16071 ecode3 = SWIG_AsVal_int(obj2, &val3);
16072 if (!SWIG_IsOK(ecode3)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16074 }
16075 arg3 = static_cast< int >(val3);
16076 if (obj3) {
16077 ecode4 = SWIG_AsVal_int(obj3, &val4);
16078 if (!SWIG_IsOK(ecode4)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16080 }
16081 arg4 = static_cast< int >(val4);
16082 }
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 result = (arg1)->Scale(arg2,arg3,arg4);
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_ResampleBox(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_ResampleBox",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_ResampleBox" "', 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_ResampleBox" "', 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_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16129 }
16130 arg3 = static_cast< int >(val3);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = ((wxImage const *)arg1)->ResampleBox(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_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj = 0;
16146 wxImage *arg1 = (wxImage *) 0 ;
16147 int arg2 ;
16148 int arg3 ;
16149 SwigValueWrapper<wxImage > result;
16150 void *argp1 = 0 ;
16151 int res1 = 0 ;
16152 int val2 ;
16153 int ecode2 = 0 ;
16154 int val3 ;
16155 int ecode3 = 0 ;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 PyObject * obj2 = 0 ;
16159 char * kwnames[] = {
16160 (char *) "self",(char *) "width",(char *) "height", NULL
16161 };
16162
16163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16165 if (!SWIG_IsOK(res1)) {
16166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16167 }
16168 arg1 = reinterpret_cast< wxImage * >(argp1);
16169 ecode2 = SWIG_AsVal_int(obj1, &val2);
16170 if (!SWIG_IsOK(ecode2)) {
16171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16172 }
16173 arg2 = static_cast< int >(val2);
16174 ecode3 = SWIG_AsVal_int(obj2, &val3);
16175 if (!SWIG_IsOK(ecode3)) {
16176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16177 }
16178 arg3 = static_cast< int >(val3);
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj = 0;
16194 wxImage *arg1 = (wxImage *) 0 ;
16195 int arg2 ;
16196 SwigValueWrapper<wxImage > result;
16197 void *argp1 = 0 ;
16198 int res1 = 0 ;
16199 int val2 ;
16200 int ecode2 = 0 ;
16201 PyObject * obj0 = 0 ;
16202 PyObject * obj1 = 0 ;
16203 char * kwnames[] = {
16204 (char *) "self",(char *) "radius", NULL
16205 };
16206
16207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16209 if (!SWIG_IsOK(res1)) {
16210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16211 }
16212 arg1 = reinterpret_cast< wxImage * >(argp1);
16213 ecode2 = SWIG_AsVal_int(obj1, &val2);
16214 if (!SWIG_IsOK(ecode2)) {
16215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16216 }
16217 arg2 = static_cast< int >(val2);
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = (arg1)->Blur(arg2);
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 int arg2 ;
16235 SwigValueWrapper<wxImage > result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 int val2 ;
16239 int ecode2 = 0 ;
16240 PyObject * obj0 = 0 ;
16241 PyObject * obj1 = 0 ;
16242 char * kwnames[] = {
16243 (char *) "self",(char *) "radius", NULL
16244 };
16245
16246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16248 if (!SWIG_IsOK(res1)) {
16249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16250 }
16251 arg1 = reinterpret_cast< wxImage * >(argp1);
16252 ecode2 = SWIG_AsVal_int(obj1, &val2);
16253 if (!SWIG_IsOK(ecode2)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16255 }
16256 arg2 = static_cast< int >(val2);
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 result = (arg1)->BlurHorizontal(arg2);
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16264 return resultobj;
16265 fail:
16266 return NULL;
16267 }
16268
16269
16270 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16271 PyObject *resultobj = 0;
16272 wxImage *arg1 = (wxImage *) 0 ;
16273 int arg2 ;
16274 SwigValueWrapper<wxImage > result;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 int val2 ;
16278 int ecode2 = 0 ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 char * kwnames[] = {
16282 (char *) "self",(char *) "radius", NULL
16283 };
16284
16285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16289 }
16290 arg1 = reinterpret_cast< wxImage * >(argp1);
16291 ecode2 = SWIG_AsVal_int(obj1, &val2);
16292 if (!SWIG_IsOK(ecode2)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16294 }
16295 arg2 = static_cast< int >(val2);
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (arg1)->BlurVertical(arg2);
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_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = 0;
16311 wxImage *arg1 = (wxImage *) 0 ;
16312 int arg2 ;
16313 int arg3 ;
16314 SwigValueWrapper<wxImage > result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 int val2 ;
16318 int ecode2 = 0 ;
16319 int val3 ;
16320 int ecode3 = 0 ;
16321 PyObject * obj0 = 0 ;
16322 PyObject * obj1 = 0 ;
16323 PyObject * obj2 = 0 ;
16324 char * kwnames[] = {
16325 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16326 };
16327
16328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16330 if (!SWIG_IsOK(res1)) {
16331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16332 }
16333 arg1 = reinterpret_cast< wxImage * >(argp1);
16334 ecode2 = SWIG_AsVal_int(obj1, &val2);
16335 if (!SWIG_IsOK(ecode2)) {
16336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16337 }
16338 arg2 = static_cast< int >(val2);
16339 ecode3 = SWIG_AsVal_int(obj2, &val3);
16340 if (!SWIG_IsOK(ecode3)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16342 }
16343 arg3 = static_cast< int >(val3);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 int arg2 ;
16361 int arg3 ;
16362 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16363 wxImage *result = 0 ;
16364 void *argp1 = 0 ;
16365 int res1 = 0 ;
16366 int val2 ;
16367 int ecode2 = 0 ;
16368 int val3 ;
16369 int ecode3 = 0 ;
16370 int val4 ;
16371 int ecode4 = 0 ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 PyObject * obj3 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16384 }
16385 arg1 = reinterpret_cast< wxImage * >(argp1);
16386 ecode2 = SWIG_AsVal_int(obj1, &val2);
16387 if (!SWIG_IsOK(ecode2)) {
16388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16389 }
16390 arg2 = static_cast< int >(val2);
16391 ecode3 = SWIG_AsVal_int(obj2, &val3);
16392 if (!SWIG_IsOK(ecode3)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16394 }
16395 arg3 = static_cast< int >(val3);
16396 if (obj3) {
16397 ecode4 = SWIG_AsVal_int(obj3, &val4);
16398 if (!SWIG_IsOK(ecode4)) {
16399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16400 }
16401 arg4 = static_cast< int >(val4);
16402 }
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 {
16406 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16407 result = (wxImage *) &_result_ref;
16408 }
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxImage *arg1 = (wxImage *) 0 ;
16422 wxSize *arg2 = 0 ;
16423 wxPoint *arg3 = 0 ;
16424 int arg4 = (int) -1 ;
16425 int arg5 = (int) -1 ;
16426 int arg6 = (int) -1 ;
16427 wxImage *result = 0 ;
16428 void *argp1 = 0 ;
16429 int res1 = 0 ;
16430 wxSize temp2 ;
16431 wxPoint temp3 ;
16432 int val4 ;
16433 int ecode4 = 0 ;
16434 int val5 ;
16435 int ecode5 = 0 ;
16436 int val6 ;
16437 int ecode6 = 0 ;
16438 PyObject * obj0 = 0 ;
16439 PyObject * obj1 = 0 ;
16440 PyObject * obj2 = 0 ;
16441 PyObject * obj3 = 0 ;
16442 PyObject * obj4 = 0 ;
16443 PyObject * obj5 = 0 ;
16444 char * kwnames[] = {
16445 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16446 };
16447
16448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16450 if (!SWIG_IsOK(res1)) {
16451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16452 }
16453 arg1 = reinterpret_cast< wxImage * >(argp1);
16454 {
16455 arg2 = &temp2;
16456 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16457 }
16458 {
16459 arg3 = &temp3;
16460 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16461 }
16462 if (obj3) {
16463 ecode4 = SWIG_AsVal_int(obj3, &val4);
16464 if (!SWIG_IsOK(ecode4)) {
16465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16466 }
16467 arg4 = static_cast< int >(val4);
16468 }
16469 if (obj4) {
16470 ecode5 = SWIG_AsVal_int(obj4, &val5);
16471 if (!SWIG_IsOK(ecode5)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16473 }
16474 arg5 = static_cast< int >(val5);
16475 }
16476 if (obj5) {
16477 ecode6 = SWIG_AsVal_int(obj5, &val6);
16478 if (!SWIG_IsOK(ecode6)) {
16479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16480 }
16481 arg6 = static_cast< int >(val6);
16482 }
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 {
16486 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16487 result = (wxImage *) &_result_ref;
16488 }
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16493 return resultobj;
16494 fail:
16495 return NULL;
16496 }
16497
16498
16499 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16500 PyObject *resultobj = 0;
16501 wxImage *arg1 = (wxImage *) 0 ;
16502 int arg2 ;
16503 int arg3 ;
16504 byte arg4 ;
16505 byte arg5 ;
16506 byte arg6 ;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 int val2 ;
16510 int ecode2 = 0 ;
16511 int val3 ;
16512 int ecode3 = 0 ;
16513 unsigned char val4 ;
16514 int ecode4 = 0 ;
16515 unsigned char val5 ;
16516 int ecode5 = 0 ;
16517 unsigned char val6 ;
16518 int ecode6 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 PyObject * obj1 = 0 ;
16521 PyObject * obj2 = 0 ;
16522 PyObject * obj3 = 0 ;
16523 PyObject * obj4 = 0 ;
16524 PyObject * obj5 = 0 ;
16525 char * kwnames[] = {
16526 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16527 };
16528
16529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16531 if (!SWIG_IsOK(res1)) {
16532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16533 }
16534 arg1 = reinterpret_cast< wxImage * >(argp1);
16535 ecode2 = SWIG_AsVal_int(obj1, &val2);
16536 if (!SWIG_IsOK(ecode2)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16538 }
16539 arg2 = static_cast< int >(val2);
16540 ecode3 = SWIG_AsVal_int(obj2, &val3);
16541 if (!SWIG_IsOK(ecode3)) {
16542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16543 }
16544 arg3 = static_cast< int >(val3);
16545 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16546 if (!SWIG_IsOK(ecode4)) {
16547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16548 }
16549 arg4 = static_cast< byte >(val4);
16550 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16551 if (!SWIG_IsOK(ecode5)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16553 }
16554 arg5 = static_cast< byte >(val5);
16555 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16556 if (!SWIG_IsOK(ecode6)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16558 }
16559 arg6 = static_cast< byte >(val6);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_Py_Void();
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxRect *arg2 = 0 ;
16577 byte arg3 ;
16578 byte arg4 ;
16579 byte arg5 ;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 wxRect temp2 ;
16583 unsigned char val3 ;
16584 int ecode3 = 0 ;
16585 unsigned char val4 ;
16586 int ecode4 = 0 ;
16587 unsigned char val5 ;
16588 int ecode5 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 PyObject * obj4 = 0 ;
16594 char * kwnames[] = {
16595 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16596 };
16597
16598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16602 }
16603 arg1 = reinterpret_cast< wxImage * >(argp1);
16604 {
16605 arg2 = &temp2;
16606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16607 }
16608 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16611 }
16612 arg3 = static_cast< byte >(val3);
16613 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16614 if (!SWIG_IsOK(ecode4)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16616 }
16617 arg4 = static_cast< byte >(val4);
16618 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16619 if (!SWIG_IsOK(ecode5)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16621 }
16622 arg5 = static_cast< byte >(val5);
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 resultobj = SWIG_Py_Void();
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 SWIGINTERN PyObject *_wrap_Image_GetRed(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_GetRed",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_GetRed" "', 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_GetRed" "', 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_GetRed" "', expected argument " "3"" of type '" "int""'");
16669 }
16670 arg3 = static_cast< int >(val3);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (byte)(arg1)->GetRed(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_GetGreen(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_GetGreen",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_GetGreen" "', 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_GetGreen" "', 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_GetGreen" "', expected argument " "3"" of type '" "int""'");
16717 }
16718 arg3 = static_cast< int >(val3);
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (byte)(arg1)->GetGreen(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_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = 0;
16734 wxImage *arg1 = (wxImage *) 0 ;
16735 int arg2 ;
16736 int arg3 ;
16737 byte result;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 int val2 ;
16741 int ecode2 = 0 ;
16742 int val3 ;
16743 int ecode3 = 0 ;
16744 PyObject * obj0 = 0 ;
16745 PyObject * obj1 = 0 ;
16746 PyObject * obj2 = 0 ;
16747 char * kwnames[] = {
16748 (char *) "self",(char *) "x",(char *) "y", NULL
16749 };
16750
16751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16753 if (!SWIG_IsOK(res1)) {
16754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16755 }
16756 arg1 = reinterpret_cast< wxImage * >(argp1);
16757 ecode2 = SWIG_AsVal_int(obj1, &val2);
16758 if (!SWIG_IsOK(ecode2)) {
16759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16760 }
16761 arg2 = static_cast< int >(val2);
16762 ecode3 = SWIG_AsVal_int(obj2, &val3);
16763 if (!SWIG_IsOK(ecode3)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16765 }
16766 arg3 = static_cast< int >(val3);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (byte)(arg1)->GetBlue(arg2,arg3);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage *arg1 = (wxImage *) 0 ;
16783 int arg2 ;
16784 int arg3 ;
16785 byte arg4 ;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 int val2 ;
16789 int ecode2 = 0 ;
16790 int val3 ;
16791 int ecode3 = 0 ;
16792 unsigned char val4 ;
16793 int ecode4 = 0 ;
16794 PyObject * obj0 = 0 ;
16795 PyObject * obj1 = 0 ;
16796 PyObject * obj2 = 0 ;
16797 PyObject * obj3 = 0 ;
16798 char * kwnames[] = {
16799 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16800 };
16801
16802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16806 }
16807 arg1 = reinterpret_cast< wxImage * >(argp1);
16808 ecode2 = SWIG_AsVal_int(obj1, &val2);
16809 if (!SWIG_IsOK(ecode2)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16811 }
16812 arg2 = static_cast< int >(val2);
16813 ecode3 = SWIG_AsVal_int(obj2, &val3);
16814 if (!SWIG_IsOK(ecode3)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16816 }
16817 arg3 = static_cast< int >(val3);
16818 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16819 if (!SWIG_IsOK(ecode4)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16821 }
16822 arg4 = static_cast< byte >(val4);
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 (arg1)->SetAlpha(arg2,arg3,arg4);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_Py_Void();
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxImage *arg1 = (wxImage *) 0 ;
16839 int arg2 ;
16840 int arg3 ;
16841 byte result;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 int val2 ;
16845 int ecode2 = 0 ;
16846 int val3 ;
16847 int ecode3 = 0 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 PyObject * obj2 = 0 ;
16851 char * kwnames[] = {
16852 (char *) "self",(char *) "x",(char *) "y", NULL
16853 };
16854
16855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16857 if (!SWIG_IsOK(res1)) {
16858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16859 }
16860 arg1 = reinterpret_cast< wxImage * >(argp1);
16861 ecode2 = SWIG_AsVal_int(obj1, &val2);
16862 if (!SWIG_IsOK(ecode2)) {
16863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16864 }
16865 arg2 = static_cast< int >(val2);
16866 ecode3 = SWIG_AsVal_int(obj2, &val3);
16867 if (!SWIG_IsOK(ecode3)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16869 }
16870 arg3 = static_cast< int >(val3);
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16885 PyObject *resultobj = 0;
16886 wxImage *arg1 = (wxImage *) 0 ;
16887 bool result;
16888 void *argp1 = 0 ;
16889 int res1 = 0 ;
16890 PyObject *swig_obj[1] ;
16891
16892 if (!args) SWIG_fail;
16893 swig_obj[0] = args;
16894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16897 }
16898 arg1 = reinterpret_cast< wxImage * >(argp1);
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (bool)(arg1)->HasAlpha();
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16907 }
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16915 PyObject *resultobj = 0;
16916 wxImage *arg1 = (wxImage *) 0 ;
16917 void *argp1 = 0 ;
16918 int res1 = 0 ;
16919 PyObject *swig_obj[1] ;
16920
16921 if (!args) SWIG_fail;
16922 swig_obj[0] = args;
16923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16924 if (!SWIG_IsOK(res1)) {
16925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16926 }
16927 arg1 = reinterpret_cast< wxImage * >(argp1);
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 (arg1)->InitAlpha();
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 resultobj = SWIG_Py_Void();
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj = 0;
16943 wxImage *arg1 = (wxImage *) 0 ;
16944 int arg2 ;
16945 int arg3 ;
16946 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16947 bool result;
16948 void *argp1 = 0 ;
16949 int res1 = 0 ;
16950 int val2 ;
16951 int ecode2 = 0 ;
16952 int val3 ;
16953 int ecode3 = 0 ;
16954 unsigned char val4 ;
16955 int ecode4 = 0 ;
16956 PyObject * obj0 = 0 ;
16957 PyObject * obj1 = 0 ;
16958 PyObject * obj2 = 0 ;
16959 PyObject * obj3 = 0 ;
16960 char * kwnames[] = {
16961 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16962 };
16963
16964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16968 }
16969 arg1 = reinterpret_cast< wxImage * >(argp1);
16970 ecode2 = SWIG_AsVal_int(obj1, &val2);
16971 if (!SWIG_IsOK(ecode2)) {
16972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16973 }
16974 arg2 = static_cast< int >(val2);
16975 ecode3 = SWIG_AsVal_int(obj2, &val3);
16976 if (!SWIG_IsOK(ecode3)) {
16977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16978 }
16979 arg3 = static_cast< int >(val3);
16980 if (obj3) {
16981 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16982 if (!SWIG_IsOK(ecode4)) {
16983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16984 }
16985 arg4 = static_cast< byte >(val4);
16986 }
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxImage *arg1 = (wxImage *) 0 ;
17005 byte *arg2 = (byte *) 0 ;
17006 byte *arg3 = (byte *) 0 ;
17007 byte *arg4 = (byte *) 0 ;
17008 byte arg5 = (byte) 0 ;
17009 byte arg6 = (byte) 0 ;
17010 byte arg7 = (byte) 0 ;
17011 bool result;
17012 void *argp1 = 0 ;
17013 int res1 = 0 ;
17014 byte temp2 ;
17015 int res2 = SWIG_TMPOBJ ;
17016 byte temp3 ;
17017 int res3 = SWIG_TMPOBJ ;
17018 byte temp4 ;
17019 int res4 = SWIG_TMPOBJ ;
17020 unsigned char val5 ;
17021 int ecode5 = 0 ;
17022 unsigned char val6 ;
17023 int ecode6 = 0 ;
17024 unsigned char val7 ;
17025 int ecode7 = 0 ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 PyObject * obj2 = 0 ;
17029 PyObject * obj3 = 0 ;
17030 char * kwnames[] = {
17031 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17032 };
17033
17034 arg2 = &temp2;
17035 arg3 = &temp3;
17036 arg4 = &temp4;
17037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17039 if (!SWIG_IsOK(res1)) {
17040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17041 }
17042 arg1 = reinterpret_cast< wxImage * >(argp1);
17043 if (obj1) {
17044 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17045 if (!SWIG_IsOK(ecode5)) {
17046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17047 }
17048 arg5 = static_cast< byte >(val5);
17049 }
17050 if (obj2) {
17051 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17052 if (!SWIG_IsOK(ecode6)) {
17053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17054 }
17055 arg6 = static_cast< byte >(val6);
17056 }
17057 if (obj3) {
17058 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17059 if (!SWIG_IsOK(ecode7)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17061 }
17062 arg7 = static_cast< byte >(val7);
17063 }
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 {
17071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17072 }
17073 if (SWIG_IsTmpObj(res2)) {
17074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17075 } else {
17076 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17078 }
17079 if (SWIG_IsTmpObj(res3)) {
17080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17081 } else {
17082 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17084 }
17085 if (SWIG_IsTmpObj(res4)) {
17086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17087 } else {
17088 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17090 }
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj = 0;
17099 wxImage *arg1 = (wxImage *) 0 ;
17100 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17101 bool result;
17102 void *argp1 = 0 ;
17103 int res1 = 0 ;
17104 unsigned char val2 ;
17105 int ecode2 = 0 ;
17106 PyObject * obj0 = 0 ;
17107 PyObject * obj1 = 0 ;
17108 char * kwnames[] = {
17109 (char *) "self",(char *) "threshold", NULL
17110 };
17111
17112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17114 if (!SWIG_IsOK(res1)) {
17115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17116 }
17117 arg1 = reinterpret_cast< wxImage * >(argp1);
17118 if (obj1) {
17119 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17120 if (!SWIG_IsOK(ecode2)) {
17121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17122 }
17123 arg2 = static_cast< byte >(val2);
17124 }
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 {
17132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17133 }
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj = 0;
17142 wxImage *arg1 = (wxImage *) 0 ;
17143 byte arg2 ;
17144 byte arg3 ;
17145 byte arg4 ;
17146 bool result;
17147 void *argp1 = 0 ;
17148 int res1 = 0 ;
17149 unsigned char val2 ;
17150 int ecode2 = 0 ;
17151 unsigned char val3 ;
17152 int ecode3 = 0 ;
17153 unsigned char val4 ;
17154 int ecode4 = 0 ;
17155 PyObject * obj0 = 0 ;
17156 PyObject * obj1 = 0 ;
17157 PyObject * obj2 = 0 ;
17158 PyObject * obj3 = 0 ;
17159 char * kwnames[] = {
17160 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17161 };
17162
17163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17165 if (!SWIG_IsOK(res1)) {
17166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17167 }
17168 arg1 = reinterpret_cast< wxImage * >(argp1);
17169 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17170 if (!SWIG_IsOK(ecode2)) {
17171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17172 }
17173 arg2 = static_cast< byte >(val2);
17174 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17175 if (!SWIG_IsOK(ecode3)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17177 }
17178 arg3 = static_cast< byte >(val3);
17179 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17180 if (!SWIG_IsOK(ecode4)) {
17181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17182 }
17183 arg4 = static_cast< byte >(val4);
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 {
17191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17192 }
17193 return resultobj;
17194 fail:
17195 return NULL;
17196 }
17197
17198
17199 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17200 PyObject *resultobj = 0;
17201 wxImage *arg1 = (wxImage *) 0 ;
17202 wxImage *arg2 = 0 ;
17203 byte arg3 ;
17204 byte arg4 ;
17205 byte arg5 ;
17206 bool result;
17207 void *argp1 = 0 ;
17208 int res1 = 0 ;
17209 void *argp2 = 0 ;
17210 int res2 = 0 ;
17211 unsigned char val3 ;
17212 int ecode3 = 0 ;
17213 unsigned char val4 ;
17214 int ecode4 = 0 ;
17215 unsigned char val5 ;
17216 int ecode5 = 0 ;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17219 PyObject * obj2 = 0 ;
17220 PyObject * obj3 = 0 ;
17221 PyObject * obj4 = 0 ;
17222 char * kwnames[] = {
17223 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17224 };
17225
17226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17228 if (!SWIG_IsOK(res1)) {
17229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17230 }
17231 arg1 = reinterpret_cast< wxImage * >(argp1);
17232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17233 if (!SWIG_IsOK(res2)) {
17234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17235 }
17236 if (!argp2) {
17237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17238 }
17239 arg2 = reinterpret_cast< wxImage * >(argp2);
17240 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17241 if (!SWIG_IsOK(ecode3)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17243 }
17244 arg3 = static_cast< byte >(val3);
17245 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17246 if (!SWIG_IsOK(ecode4)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17248 }
17249 arg4 = static_cast< byte >(val4);
17250 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17251 if (!SWIG_IsOK(ecode5)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17253 }
17254 arg5 = static_cast< byte >(val5);
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj = 0;
17272 wxString *arg1 = 0 ;
17273 bool result;
17274 bool temp1 = false ;
17275 PyObject * obj0 = 0 ;
17276 char * kwnames[] = {
17277 (char *) "filename", NULL
17278 };
17279
17280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17281 {
17282 arg1 = wxString_in_helper(obj0);
17283 if (arg1 == NULL) SWIG_fail;
17284 temp1 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17294 }
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_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxString *arg1 = 0 ;
17312 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17313 int result;
17314 bool temp1 = false ;
17315 long val2 ;
17316 int ecode2 = 0 ;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 char * kwnames[] = {
17320 (char *) "filename",(char *) "type", NULL
17321 };
17322
17323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17324 {
17325 arg1 = wxString_in_helper(obj0);
17326 if (arg1 == NULL) SWIG_fail;
17327 temp1 = true;
17328 }
17329 if (obj1) {
17330 ecode2 = SWIG_AsVal_long(obj1, &val2);
17331 if (!SWIG_IsOK(ecode2)) {
17332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17333 }
17334 arg2 = static_cast< long >(val2);
17335 }
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_From_int(static_cast< int >(result));
17343 {
17344 if (temp1)
17345 delete arg1;
17346 }
17347 return resultobj;
17348 fail:
17349 {
17350 if (temp1)
17351 delete arg1;
17352 }
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = 0;
17359 wxImage *arg1 = (wxImage *) 0 ;
17360 wxString *arg2 = 0 ;
17361 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17362 int arg4 = (int) -1 ;
17363 bool result;
17364 void *argp1 = 0 ;
17365 int res1 = 0 ;
17366 bool temp2 = false ;
17367 long val3 ;
17368 int ecode3 = 0 ;
17369 int val4 ;
17370 int ecode4 = 0 ;
17371 PyObject * obj0 = 0 ;
17372 PyObject * obj1 = 0 ;
17373 PyObject * obj2 = 0 ;
17374 PyObject * obj3 = 0 ;
17375 char * kwnames[] = {
17376 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17377 };
17378
17379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17381 if (!SWIG_IsOK(res1)) {
17382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17383 }
17384 arg1 = reinterpret_cast< wxImage * >(argp1);
17385 {
17386 arg2 = wxString_in_helper(obj1);
17387 if (arg2 == NULL) SWIG_fail;
17388 temp2 = true;
17389 }
17390 if (obj2) {
17391 ecode3 = SWIG_AsVal_long(obj2, &val3);
17392 if (!SWIG_IsOK(ecode3)) {
17393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17394 }
17395 arg3 = static_cast< long >(val3);
17396 }
17397 if (obj3) {
17398 ecode4 = SWIG_AsVal_int(obj3, &val4);
17399 if (!SWIG_IsOK(ecode4)) {
17400 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17401 }
17402 arg4 = static_cast< int >(val4);
17403 }
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17412 }
17413 {
17414 if (temp2)
17415 delete arg2;
17416 }
17417 return resultobj;
17418 fail:
17419 {
17420 if (temp2)
17421 delete arg2;
17422 }
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17428 PyObject *resultobj = 0;
17429 wxImage *arg1 = (wxImage *) 0 ;
17430 wxString *arg2 = 0 ;
17431 wxString *arg3 = 0 ;
17432 int arg4 = (int) -1 ;
17433 bool result;
17434 void *argp1 = 0 ;
17435 int res1 = 0 ;
17436 bool temp2 = false ;
17437 bool temp3 = false ;
17438 int val4 ;
17439 int ecode4 = 0 ;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 PyObject * obj2 = 0 ;
17443 PyObject * obj3 = 0 ;
17444 char * kwnames[] = {
17445 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17446 };
17447
17448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17450 if (!SWIG_IsOK(res1)) {
17451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17452 }
17453 arg1 = reinterpret_cast< wxImage * >(argp1);
17454 {
17455 arg2 = wxString_in_helper(obj1);
17456 if (arg2 == NULL) SWIG_fail;
17457 temp2 = true;
17458 }
17459 {
17460 arg3 = wxString_in_helper(obj2);
17461 if (arg3 == NULL) SWIG_fail;
17462 temp3 = true;
17463 }
17464 if (obj3) {
17465 ecode4 = SWIG_AsVal_int(obj3, &val4);
17466 if (!SWIG_IsOK(ecode4)) {
17467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17468 }
17469 arg4 = static_cast< int >(val4);
17470 }
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17479 }
17480 {
17481 if (temp2)
17482 delete arg2;
17483 }
17484 {
17485 if (temp3)
17486 delete arg3;
17487 }
17488 return resultobj;
17489 fail:
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 {
17495 if (temp3)
17496 delete arg3;
17497 }
17498 return NULL;
17499 }
17500
17501
17502 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17503 PyObject *resultobj = 0;
17504 wxImage *arg1 = (wxImage *) 0 ;
17505 wxString *arg2 = 0 ;
17506 int arg3 ;
17507 bool result;
17508 void *argp1 = 0 ;
17509 int res1 = 0 ;
17510 bool temp2 = false ;
17511 int val3 ;
17512 int ecode3 = 0 ;
17513 PyObject * obj0 = 0 ;
17514 PyObject * obj1 = 0 ;
17515 PyObject * obj2 = 0 ;
17516 char * kwnames[] = {
17517 (char *) "self",(char *) "name",(char *) "type", NULL
17518 };
17519
17520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17522 if (!SWIG_IsOK(res1)) {
17523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17524 }
17525 arg1 = reinterpret_cast< wxImage * >(argp1);
17526 {
17527 arg2 = wxString_in_helper(obj1);
17528 if (arg2 == NULL) SWIG_fail;
17529 temp2 = true;
17530 }
17531 ecode3 = SWIG_AsVal_int(obj2, &val3);
17532 if (!SWIG_IsOK(ecode3)) {
17533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17534 }
17535 arg3 = static_cast< int >(val3);
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17544 }
17545 {
17546 if (temp2)
17547 delete arg2;
17548 }
17549 return resultobj;
17550 fail:
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxImage *arg1 = (wxImage *) 0 ;
17562 wxString *arg2 = 0 ;
17563 wxString *arg3 = 0 ;
17564 bool result;
17565 void *argp1 = 0 ;
17566 int res1 = 0 ;
17567 bool temp2 = false ;
17568 bool temp3 = false ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 PyObject * obj2 = 0 ;
17572 char * kwnames[] = {
17573 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17574 };
17575
17576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17578 if (!SWIG_IsOK(res1)) {
17579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17580 }
17581 arg1 = reinterpret_cast< wxImage * >(argp1);
17582 {
17583 arg2 = wxString_in_helper(obj1);
17584 if (arg2 == NULL) SWIG_fail;
17585 temp2 = true;
17586 }
17587 {
17588 arg3 = wxString_in_helper(obj2);
17589 if (arg3 == NULL) SWIG_fail;
17590 temp3 = true;
17591 }
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 {
17599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17600 }
17601 {
17602 if (temp2)
17603 delete arg2;
17604 }
17605 {
17606 if (temp3)
17607 delete arg3;
17608 }
17609 return resultobj;
17610 fail:
17611 {
17612 if (temp2)
17613 delete arg2;
17614 }
17615 {
17616 if (temp3)
17617 delete arg3;
17618 }
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj = 0;
17625 wxInputStream *arg1 = 0 ;
17626 bool result;
17627 wxPyInputStream *temp1 ;
17628 bool created1 ;
17629 PyObject * obj0 = 0 ;
17630 char * kwnames[] = {
17631 (char *) "stream", NULL
17632 };
17633
17634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17635 {
17636 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17637 arg1 = temp1->m_wxis;
17638 created1 = false;
17639 } else {
17640 PyErr_Clear(); // clear the failure of the wxPyConvert above
17641 arg1 = wxPyCBInputStream_create(obj0, false);
17642 if (arg1 == NULL) {
17643 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17644 SWIG_fail;
17645 }
17646 created1 = true;
17647 }
17648 }
17649 {
17650 PyThreadState* __tstate = wxPyBeginAllowThreads();
17651 result = (bool)wxImage::CanRead(*arg1);
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 {
17656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17657 }
17658 {
17659 if (created1) delete arg1;
17660 }
17661 return resultobj;
17662 fail:
17663 {
17664 if (created1) delete arg1;
17665 }
17666 return NULL;
17667 }
17668
17669
17670 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17671 PyObject *resultobj = 0;
17672 wxImage *arg1 = (wxImage *) 0 ;
17673 wxInputStream *arg2 = 0 ;
17674 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17675 int arg4 = (int) -1 ;
17676 bool result;
17677 void *argp1 = 0 ;
17678 int res1 = 0 ;
17679 wxPyInputStream *temp2 ;
17680 bool created2 ;
17681 long val3 ;
17682 int ecode3 = 0 ;
17683 int val4 ;
17684 int ecode4 = 0 ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17687 PyObject * obj2 = 0 ;
17688 PyObject * obj3 = 0 ;
17689 char * kwnames[] = {
17690 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17691 };
17692
17693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17695 if (!SWIG_IsOK(res1)) {
17696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17697 }
17698 arg1 = reinterpret_cast< wxImage * >(argp1);
17699 {
17700 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17701 arg2 = temp2->m_wxis;
17702 created2 = false;
17703 } else {
17704 PyErr_Clear(); // clear the failure of the wxPyConvert above
17705 arg2 = wxPyCBInputStream_create(obj1, false);
17706 if (arg2 == NULL) {
17707 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17708 SWIG_fail;
17709 }
17710 created2 = true;
17711 }
17712 }
17713 if (obj2) {
17714 ecode3 = SWIG_AsVal_long(obj2, &val3);
17715 if (!SWIG_IsOK(ecode3)) {
17716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17717 }
17718 arg3 = static_cast< long >(val3);
17719 }
17720 if (obj3) {
17721 ecode4 = SWIG_AsVal_int(obj3, &val4);
17722 if (!SWIG_IsOK(ecode4)) {
17723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17724 }
17725 arg4 = static_cast< int >(val4);
17726 }
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 {
17734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17735 }
17736 {
17737 if (created2) delete arg2;
17738 }
17739 return resultobj;
17740 fail:
17741 {
17742 if (created2) delete arg2;
17743 }
17744 return NULL;
17745 }
17746
17747
17748 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = 0;
17750 wxImage *arg1 = (wxImage *) 0 ;
17751 wxInputStream *arg2 = 0 ;
17752 wxString *arg3 = 0 ;
17753 int arg4 = (int) -1 ;
17754 bool result;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 wxPyInputStream *temp2 ;
17758 bool created2 ;
17759 bool temp3 = false ;
17760 int val4 ;
17761 int ecode4 = 0 ;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 PyObject * obj2 = 0 ;
17765 PyObject * obj3 = 0 ;
17766 char * kwnames[] = {
17767 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17768 };
17769
17770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17774 }
17775 arg1 = reinterpret_cast< wxImage * >(argp1);
17776 {
17777 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17778 arg2 = temp2->m_wxis;
17779 created2 = false;
17780 } else {
17781 PyErr_Clear(); // clear the failure of the wxPyConvert above
17782 arg2 = wxPyCBInputStream_create(obj1, false);
17783 if (arg2 == NULL) {
17784 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17785 SWIG_fail;
17786 }
17787 created2 = true;
17788 }
17789 }
17790 {
17791 arg3 = wxString_in_helper(obj2);
17792 if (arg3 == NULL) SWIG_fail;
17793 temp3 = true;
17794 }
17795 if (obj3) {
17796 ecode4 = SWIG_AsVal_int(obj3, &val4);
17797 if (!SWIG_IsOK(ecode4)) {
17798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17799 }
17800 arg4 = static_cast< int >(val4);
17801 }
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 {
17809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17810 }
17811 {
17812 if (created2) delete arg2;
17813 }
17814 {
17815 if (temp3)
17816 delete arg3;
17817 }
17818 return resultobj;
17819 fail:
17820 {
17821 if (created2) delete arg2;
17822 }
17823 {
17824 if (temp3)
17825 delete arg3;
17826 }
17827 return NULL;
17828 }
17829
17830
17831 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17832 PyObject *resultobj = 0;
17833 wxImage *arg1 = (wxImage *) 0 ;
17834 bool result;
17835 void *argp1 = 0 ;
17836 int res1 = 0 ;
17837 PyObject *swig_obj[1] ;
17838
17839 if (!args) SWIG_fail;
17840 swig_obj[0] = args;
17841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17842 if (!SWIG_IsOK(res1)) {
17843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17844 }
17845 arg1 = reinterpret_cast< wxImage * >(argp1);
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->IsOk();
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 {
17853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17854 }
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17862 PyObject *resultobj = 0;
17863 wxImage *arg1 = (wxImage *) 0 ;
17864 int result;
17865 void *argp1 = 0 ;
17866 int res1 = 0 ;
17867 PyObject *swig_obj[1] ;
17868
17869 if (!args) SWIG_fail;
17870 swig_obj[0] = args;
17871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17872 if (!SWIG_IsOK(res1)) {
17873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17874 }
17875 arg1 = reinterpret_cast< wxImage * >(argp1);
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (int)(arg1)->GetWidth();
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 resultobj = SWIG_From_int(static_cast< int >(result));
17883 return resultobj;
17884 fail:
17885 return NULL;
17886 }
17887
17888
17889 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17890 PyObject *resultobj = 0;
17891 wxImage *arg1 = (wxImage *) 0 ;
17892 int result;
17893 void *argp1 = 0 ;
17894 int res1 = 0 ;
17895 PyObject *swig_obj[1] ;
17896
17897 if (!args) SWIG_fail;
17898 swig_obj[0] = args;
17899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17900 if (!SWIG_IsOK(res1)) {
17901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17902 }
17903 arg1 = reinterpret_cast< wxImage * >(argp1);
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 result = (int)(arg1)->GetHeight();
17907 wxPyEndAllowThreads(__tstate);
17908 if (PyErr_Occurred()) SWIG_fail;
17909 }
17910 resultobj = SWIG_From_int(static_cast< int >(result));
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 PyObject *resultobj = 0;
17919 wxImage *arg1 = (wxImage *) 0 ;
17920 wxSize result;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 PyObject *swig_obj[1] ;
17924
17925 if (!args) SWIG_fail;
17926 swig_obj[0] = args;
17927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17930 }
17931 arg1 = reinterpret_cast< wxImage * >(argp1);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = wxImage_GetSize(arg1);
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj = 0;
17947 wxImage *arg1 = (wxImage *) 0 ;
17948 wxRect *arg2 = 0 ;
17949 SwigValueWrapper<wxImage > result;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 wxRect temp2 ;
17953 PyObject * obj0 = 0 ;
17954 PyObject * obj1 = 0 ;
17955 char * kwnames[] = {
17956 (char *) "self",(char *) "rect", NULL
17957 };
17958
17959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17961 if (!SWIG_IsOK(res1)) {
17962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17963 }
17964 arg1 = reinterpret_cast< wxImage * >(argp1);
17965 {
17966 arg2 = &temp2;
17967 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17968 }
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj = 0;
17984 wxImage *arg1 = (wxImage *) 0 ;
17985 wxSize *arg2 = 0 ;
17986 wxPoint *arg3 = 0 ;
17987 int arg4 = (int) -1 ;
17988 int arg5 = (int) -1 ;
17989 int arg6 = (int) -1 ;
17990 SwigValueWrapper<wxImage > result;
17991 void *argp1 = 0 ;
17992 int res1 = 0 ;
17993 wxSize temp2 ;
17994 wxPoint temp3 ;
17995 int val4 ;
17996 int ecode4 = 0 ;
17997 int val5 ;
17998 int ecode5 = 0 ;
17999 int val6 ;
18000 int ecode6 = 0 ;
18001 PyObject * obj0 = 0 ;
18002 PyObject * obj1 = 0 ;
18003 PyObject * obj2 = 0 ;
18004 PyObject * obj3 = 0 ;
18005 PyObject * obj4 = 0 ;
18006 PyObject * obj5 = 0 ;
18007 char * kwnames[] = {
18008 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18009 };
18010
18011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18013 if (!SWIG_IsOK(res1)) {
18014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18015 }
18016 arg1 = reinterpret_cast< wxImage * >(argp1);
18017 {
18018 arg2 = &temp2;
18019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18020 }
18021 {
18022 arg3 = &temp3;
18023 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18024 }
18025 if (obj3) {
18026 ecode4 = SWIG_AsVal_int(obj3, &val4);
18027 if (!SWIG_IsOK(ecode4)) {
18028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18029 }
18030 arg4 = static_cast< int >(val4);
18031 }
18032 if (obj4) {
18033 ecode5 = SWIG_AsVal_int(obj4, &val5);
18034 if (!SWIG_IsOK(ecode5)) {
18035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18036 }
18037 arg5 = static_cast< int >(val5);
18038 }
18039 if (obj5) {
18040 ecode6 = SWIG_AsVal_int(obj5, &val6);
18041 if (!SWIG_IsOK(ecode6)) {
18042 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18043 }
18044 arg6 = static_cast< int >(val6);
18045 }
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 PyObject *resultobj = 0;
18061 wxImage *arg1 = (wxImage *) 0 ;
18062 SwigValueWrapper<wxImage > result;
18063 void *argp1 = 0 ;
18064 int res1 = 0 ;
18065 PyObject *swig_obj[1] ;
18066
18067 if (!args) SWIG_fail;
18068 swig_obj[0] = args;
18069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18072 }
18073 arg1 = reinterpret_cast< wxImage * >(argp1);
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (arg1)->Copy();
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj = 0;
18089 wxImage *arg1 = (wxImage *) 0 ;
18090 wxImage *arg2 = 0 ;
18091 int arg3 ;
18092 int arg4 ;
18093 void *argp1 = 0 ;
18094 int res1 = 0 ;
18095 void *argp2 = 0 ;
18096 int res2 = 0 ;
18097 int val3 ;
18098 int ecode3 = 0 ;
18099 int val4 ;
18100 int ecode4 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 PyObject * obj2 = 0 ;
18104 PyObject * obj3 = 0 ;
18105 char * kwnames[] = {
18106 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18107 };
18108
18109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18113 }
18114 arg1 = reinterpret_cast< wxImage * >(argp1);
18115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18116 if (!SWIG_IsOK(res2)) {
18117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18118 }
18119 if (!argp2) {
18120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18121 }
18122 arg2 = reinterpret_cast< wxImage * >(argp2);
18123 ecode3 = SWIG_AsVal_int(obj2, &val3);
18124 if (!SWIG_IsOK(ecode3)) {
18125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18126 }
18127 arg3 = static_cast< int >(val3);
18128 ecode4 = SWIG_AsVal_int(obj3, &val4);
18129 if (!SWIG_IsOK(ecode4)) {
18130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18131 }
18132 arg4 = static_cast< int >(val4);
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_Py_Void();
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 PyObject *resultobj = 0;
18148 wxImage *arg1 = (wxImage *) 0 ;
18149 PyObject *result = 0 ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 PyObject *swig_obj[1] ;
18153
18154 if (!args) SWIG_fail;
18155 swig_obj[0] = args;
18156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18157 if (!SWIG_IsOK(res1)) {
18158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18159 }
18160 arg1 = reinterpret_cast< wxImage * >(argp1);
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (PyObject *)wxImage_GetData(arg1);
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = result;
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj = 0;
18176 wxImage *arg1 = (wxImage *) 0 ;
18177 buffer arg2 ;
18178 int arg3 ;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 Py_ssize_t temp2 ;
18182 PyObject * obj0 = 0 ;
18183 PyObject * obj1 = 0 ;
18184 char * kwnames[] = {
18185 (char *) "self",(char *) "data", NULL
18186 };
18187
18188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18190 if (!SWIG_IsOK(res1)) {
18191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18192 }
18193 arg1 = reinterpret_cast< wxImage * >(argp1);
18194 {
18195 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18196 arg3 = (int)temp2;
18197 }
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 wxImage_SetData(arg1,arg2,arg3);
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 resultobj = SWIG_Py_Void();
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18212 PyObject *resultobj = 0;
18213 wxImage *arg1 = (wxImage *) 0 ;
18214 PyObject *result = 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 PyObject *swig_obj[1] ;
18218
18219 if (!args) SWIG_fail;
18220 swig_obj[0] = args;
18221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18222 if (!SWIG_IsOK(res1)) {
18223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18224 }
18225 arg1 = reinterpret_cast< wxImage * >(argp1);
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = result;
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18240 PyObject *resultobj = 0;
18241 wxImage *arg1 = (wxImage *) 0 ;
18242 buffer arg2 ;
18243 int arg3 ;
18244 void *argp1 = 0 ;
18245 int res1 = 0 ;
18246 Py_ssize_t temp2 ;
18247 PyObject * obj0 = 0 ;
18248 PyObject * obj1 = 0 ;
18249 char * kwnames[] = {
18250 (char *) "self",(char *) "data", NULL
18251 };
18252
18253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18255 if (!SWIG_IsOK(res1)) {
18256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18257 }
18258 arg1 = reinterpret_cast< wxImage * >(argp1);
18259 {
18260 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18261 arg3 = (int)temp2;
18262 }
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 wxImage_SetDataBuffer(arg1,arg2,arg3);
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = SWIG_Py_Void();
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18277 PyObject *resultobj = 0;
18278 wxImage *arg1 = (wxImage *) 0 ;
18279 PyObject *result = 0 ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 PyObject *swig_obj[1] ;
18283
18284 if (!args) SWIG_fail;
18285 swig_obj[0] = args;
18286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18287 if (!SWIG_IsOK(res1)) {
18288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18289 }
18290 arg1 = reinterpret_cast< wxImage * >(argp1);
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (PyObject *)wxImage_GetAlphaData(arg1);
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 resultobj = result;
18298 return resultobj;
18299 fail:
18300 return NULL;
18301 }
18302
18303
18304 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj = 0;
18306 wxImage *arg1 = (wxImage *) 0 ;
18307 buffer arg2 ;
18308 int arg3 ;
18309 void *argp1 = 0 ;
18310 int res1 = 0 ;
18311 Py_ssize_t temp2 ;
18312 PyObject * obj0 = 0 ;
18313 PyObject * obj1 = 0 ;
18314 char * kwnames[] = {
18315 (char *) "self",(char *) "alpha", NULL
18316 };
18317
18318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18320 if (!SWIG_IsOK(res1)) {
18321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18322 }
18323 arg1 = reinterpret_cast< wxImage * >(argp1);
18324 {
18325 if (obj1 != Py_None) {
18326 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18327 arg3 = (int)temp2;
18328 }
18329 }
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 wxImage_SetAlphaData(arg1,arg2,arg3);
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 resultobj = SWIG_Py_Void();
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18344 PyObject *resultobj = 0;
18345 wxImage *arg1 = (wxImage *) 0 ;
18346 PyObject *result = 0 ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 PyObject *swig_obj[1] ;
18350
18351 if (!args) SWIG_fail;
18352 swig_obj[0] = args;
18353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18354 if (!SWIG_IsOK(res1)) {
18355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18356 }
18357 arg1 = reinterpret_cast< wxImage * >(argp1);
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 resultobj = result;
18365 return resultobj;
18366 fail:
18367 return NULL;
18368 }
18369
18370
18371 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj = 0;
18373 wxImage *arg1 = (wxImage *) 0 ;
18374 buffer arg2 ;
18375 int arg3 ;
18376 void *argp1 = 0 ;
18377 int res1 = 0 ;
18378 Py_ssize_t temp2 ;
18379 PyObject * obj0 = 0 ;
18380 PyObject * obj1 = 0 ;
18381 char * kwnames[] = {
18382 (char *) "self",(char *) "alpha", NULL
18383 };
18384
18385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18387 if (!SWIG_IsOK(res1)) {
18388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18389 }
18390 arg1 = reinterpret_cast< wxImage * >(argp1);
18391 {
18392 if (obj1 != Py_None) {
18393 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18394 arg3 = (int)temp2;
18395 }
18396 }
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 resultobj = SWIG_Py_Void();
18404 return resultobj;
18405 fail:
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj = 0;
18412 wxImage *arg1 = (wxImage *) 0 ;
18413 byte arg2 ;
18414 byte arg3 ;
18415 byte arg4 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 unsigned char val2 ;
18419 int ecode2 = 0 ;
18420 unsigned char val3 ;
18421 int ecode3 = 0 ;
18422 unsigned char val4 ;
18423 int ecode4 = 0 ;
18424 PyObject * obj0 = 0 ;
18425 PyObject * obj1 = 0 ;
18426 PyObject * obj2 = 0 ;
18427 PyObject * obj3 = 0 ;
18428 char * kwnames[] = {
18429 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18430 };
18431
18432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18434 if (!SWIG_IsOK(res1)) {
18435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18436 }
18437 arg1 = reinterpret_cast< wxImage * >(argp1);
18438 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18439 if (!SWIG_IsOK(ecode2)) {
18440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18441 }
18442 arg2 = static_cast< byte >(val2);
18443 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18444 if (!SWIG_IsOK(ecode3)) {
18445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18446 }
18447 arg3 = static_cast< byte >(val3);
18448 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18449 if (!SWIG_IsOK(ecode4)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18451 }
18452 arg4 = static_cast< byte >(val4);
18453 {
18454 PyThreadState* __tstate = wxPyBeginAllowThreads();
18455 (arg1)->SetMaskColour(arg2,arg3,arg4);
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 resultobj = SWIG_Py_Void();
18460 return resultobj;
18461 fail:
18462 return NULL;
18463 }
18464
18465
18466 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18467 PyObject *resultobj = 0;
18468 wxImage *arg1 = (wxImage *) 0 ;
18469 byte *arg2 = (byte *) 0 ;
18470 byte *arg3 = (byte *) 0 ;
18471 byte *arg4 = (byte *) 0 ;
18472 void *argp1 = 0 ;
18473 int res1 = 0 ;
18474 byte temp2 ;
18475 int res2 = SWIG_TMPOBJ ;
18476 byte temp3 ;
18477 int res3 = SWIG_TMPOBJ ;
18478 byte temp4 ;
18479 int res4 = SWIG_TMPOBJ ;
18480 PyObject *swig_obj[1] ;
18481
18482 arg2 = &temp2;
18483 arg3 = &temp3;
18484 arg4 = &temp4;
18485 if (!args) SWIG_fail;
18486 swig_obj[0] = args;
18487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18488 if (!SWIG_IsOK(res1)) {
18489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18490 }
18491 arg1 = reinterpret_cast< wxImage * >(argp1);
18492 {
18493 PyThreadState* __tstate = wxPyBeginAllowThreads();
18494 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18495 wxPyEndAllowThreads(__tstate);
18496 if (PyErr_Occurred()) SWIG_fail;
18497 }
18498 resultobj = SWIG_Py_Void();
18499 if (SWIG_IsTmpObj(res2)) {
18500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18501 } else {
18502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18504 }
18505 if (SWIG_IsTmpObj(res3)) {
18506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18507 } else {
18508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18510 }
18511 if (SWIG_IsTmpObj(res4)) {
18512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18513 } else {
18514 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18516 }
18517 return resultobj;
18518 fail:
18519 return NULL;
18520 }
18521
18522
18523 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18524 PyObject *resultobj = 0;
18525 wxImage *arg1 = (wxImage *) 0 ;
18526 byte result;
18527 void *argp1 = 0 ;
18528 int res1 = 0 ;
18529 PyObject *swig_obj[1] ;
18530
18531 if (!args) SWIG_fail;
18532 swig_obj[0] = args;
18533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18536 }
18537 arg1 = reinterpret_cast< wxImage * >(argp1);
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 result = (byte)(arg1)->GetMaskRed();
18541 wxPyEndAllowThreads(__tstate);
18542 if (PyErr_Occurred()) SWIG_fail;
18543 }
18544 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18545 return resultobj;
18546 fail:
18547 return NULL;
18548 }
18549
18550
18551 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18552 PyObject *resultobj = 0;
18553 wxImage *arg1 = (wxImage *) 0 ;
18554 byte result;
18555 void *argp1 = 0 ;
18556 int res1 = 0 ;
18557 PyObject *swig_obj[1] ;
18558
18559 if (!args) SWIG_fail;
18560 swig_obj[0] = args;
18561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18562 if (!SWIG_IsOK(res1)) {
18563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18564 }
18565 arg1 = reinterpret_cast< wxImage * >(argp1);
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (byte)(arg1)->GetMaskGreen();
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxImage *arg1 = (wxImage *) 0 ;
18582 byte result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18592 }
18593 arg1 = reinterpret_cast< wxImage * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (byte)(arg1)->GetMaskBlue();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = 0;
18609 wxImage *arg1 = (wxImage *) 0 ;
18610 bool arg2 = (bool) true ;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 bool val2 ;
18614 int ecode2 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "self",(char *) "mask", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18625 }
18626 arg1 = reinterpret_cast< wxImage * >(argp1);
18627 if (obj1) {
18628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18629 if (!SWIG_IsOK(ecode2)) {
18630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18631 }
18632 arg2 = static_cast< bool >(val2);
18633 }
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 (arg1)->SetMask(arg2);
18637 wxPyEndAllowThreads(__tstate);
18638 if (PyErr_Occurred()) SWIG_fail;
18639 }
18640 resultobj = SWIG_Py_Void();
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18648 PyObject *resultobj = 0;
18649 wxImage *arg1 = (wxImage *) 0 ;
18650 bool result;
18651 void *argp1 = 0 ;
18652 int res1 = 0 ;
18653 PyObject *swig_obj[1] ;
18654
18655 if (!args) SWIG_fail;
18656 swig_obj[0] = args;
18657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18658 if (!SWIG_IsOK(res1)) {
18659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18660 }
18661 arg1 = reinterpret_cast< wxImage * >(argp1);
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 result = (bool)(arg1)->HasMask();
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 {
18669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18670 }
18671 return resultobj;
18672 fail:
18673 return NULL;
18674 }
18675
18676
18677 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18678 PyObject *resultobj = 0;
18679 wxImage *arg1 = (wxImage *) 0 ;
18680 double arg2 ;
18681 wxPoint *arg3 = 0 ;
18682 bool arg4 = (bool) true ;
18683 wxPoint *arg5 = (wxPoint *) NULL ;
18684 SwigValueWrapper<wxImage > result;
18685 void *argp1 = 0 ;
18686 int res1 = 0 ;
18687 double val2 ;
18688 int ecode2 = 0 ;
18689 wxPoint temp3 ;
18690 bool val4 ;
18691 int ecode4 = 0 ;
18692 void *argp5 = 0 ;
18693 int res5 = 0 ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 PyObject * obj2 = 0 ;
18697 PyObject * obj3 = 0 ;
18698 PyObject * obj4 = 0 ;
18699 char * kwnames[] = {
18700 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18701 };
18702
18703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18705 if (!SWIG_IsOK(res1)) {
18706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18707 }
18708 arg1 = reinterpret_cast< wxImage * >(argp1);
18709 ecode2 = SWIG_AsVal_double(obj1, &val2);
18710 if (!SWIG_IsOK(ecode2)) {
18711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18712 }
18713 arg2 = static_cast< double >(val2);
18714 {
18715 arg3 = &temp3;
18716 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18717 }
18718 if (obj3) {
18719 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18720 if (!SWIG_IsOK(ecode4)) {
18721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18722 }
18723 arg4 = static_cast< bool >(val4);
18724 }
18725 if (obj4) {
18726 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18727 if (!SWIG_IsOK(res5)) {
18728 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18729 }
18730 arg5 = reinterpret_cast< wxPoint * >(argp5);
18731 }
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18739 return resultobj;
18740 fail:
18741 return NULL;
18742 }
18743
18744
18745 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18746 PyObject *resultobj = 0;
18747 wxImage *arg1 = (wxImage *) 0 ;
18748 bool arg2 = (bool) true ;
18749 SwigValueWrapper<wxImage > result;
18750 void *argp1 = 0 ;
18751 int res1 = 0 ;
18752 bool val2 ;
18753 int ecode2 = 0 ;
18754 PyObject * obj0 = 0 ;
18755 PyObject * obj1 = 0 ;
18756 char * kwnames[] = {
18757 (char *) "self",(char *) "clockwise", NULL
18758 };
18759
18760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18762 if (!SWIG_IsOK(res1)) {
18763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18764 }
18765 arg1 = reinterpret_cast< wxImage * >(argp1);
18766 if (obj1) {
18767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18768 if (!SWIG_IsOK(ecode2)) {
18769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18770 }
18771 arg2 = static_cast< bool >(val2);
18772 }
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (arg1)->Rotate90(arg2);
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18787 PyObject *resultobj = 0;
18788 wxImage *arg1 = (wxImage *) 0 ;
18789 bool arg2 = (bool) true ;
18790 SwigValueWrapper<wxImage > result;
18791 void *argp1 = 0 ;
18792 int res1 = 0 ;
18793 bool val2 ;
18794 int ecode2 = 0 ;
18795 PyObject * obj0 = 0 ;
18796 PyObject * obj1 = 0 ;
18797 char * kwnames[] = {
18798 (char *) "self",(char *) "horizontally", NULL
18799 };
18800
18801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18803 if (!SWIG_IsOK(res1)) {
18804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18805 }
18806 arg1 = reinterpret_cast< wxImage * >(argp1);
18807 if (obj1) {
18808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18809 if (!SWIG_IsOK(ecode2)) {
18810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18811 }
18812 arg2 = static_cast< bool >(val2);
18813 }
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = (arg1)->Mirror(arg2);
18817 wxPyEndAllowThreads(__tstate);
18818 if (PyErr_Occurred()) SWIG_fail;
18819 }
18820 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18828 PyObject *resultobj = 0;
18829 wxImage *arg1 = (wxImage *) 0 ;
18830 byte arg2 ;
18831 byte arg3 ;
18832 byte arg4 ;
18833 byte arg5 ;
18834 byte arg6 ;
18835 byte arg7 ;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 unsigned char val2 ;
18839 int ecode2 = 0 ;
18840 unsigned char val3 ;
18841 int ecode3 = 0 ;
18842 unsigned char val4 ;
18843 int ecode4 = 0 ;
18844 unsigned char val5 ;
18845 int ecode5 = 0 ;
18846 unsigned char val6 ;
18847 int ecode6 = 0 ;
18848 unsigned char val7 ;
18849 int ecode7 = 0 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 PyObject * obj2 = 0 ;
18853 PyObject * obj3 = 0 ;
18854 PyObject * obj4 = 0 ;
18855 PyObject * obj5 = 0 ;
18856 PyObject * obj6 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18863 if (!SWIG_IsOK(res1)) {
18864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18865 }
18866 arg1 = reinterpret_cast< wxImage * >(argp1);
18867 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18868 if (!SWIG_IsOK(ecode2)) {
18869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18870 }
18871 arg2 = static_cast< byte >(val2);
18872 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18873 if (!SWIG_IsOK(ecode3)) {
18874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18875 }
18876 arg3 = static_cast< byte >(val3);
18877 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18878 if (!SWIG_IsOK(ecode4)) {
18879 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18880 }
18881 arg4 = static_cast< byte >(val4);
18882 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18883 if (!SWIG_IsOK(ecode5)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18885 }
18886 arg5 = static_cast< byte >(val5);
18887 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18888 if (!SWIG_IsOK(ecode6)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18890 }
18891 arg6 = static_cast< byte >(val6);
18892 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18893 if (!SWIG_IsOK(ecode7)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18895 }
18896 arg7 = static_cast< byte >(val7);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_Py_Void();
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = 0;
18912 wxImage *arg1 = (wxImage *) 0 ;
18913 double arg2 = (double) 0.299 ;
18914 double arg3 = (double) 0.587 ;
18915 double arg4 = (double) 0.114 ;
18916 SwigValueWrapper<wxImage > result;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 double val2 ;
18920 int ecode2 = 0 ;
18921 double val3 ;
18922 int ecode3 = 0 ;
18923 double val4 ;
18924 int ecode4 = 0 ;
18925 PyObject * obj0 = 0 ;
18926 PyObject * obj1 = 0 ;
18927 PyObject * obj2 = 0 ;
18928 PyObject * obj3 = 0 ;
18929 char * kwnames[] = {
18930 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18931 };
18932
18933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18935 if (!SWIG_IsOK(res1)) {
18936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18937 }
18938 arg1 = reinterpret_cast< wxImage * >(argp1);
18939 if (obj1) {
18940 ecode2 = SWIG_AsVal_double(obj1, &val2);
18941 if (!SWIG_IsOK(ecode2)) {
18942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18943 }
18944 arg2 = static_cast< double >(val2);
18945 }
18946 if (obj2) {
18947 ecode3 = SWIG_AsVal_double(obj2, &val3);
18948 if (!SWIG_IsOK(ecode3)) {
18949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18950 }
18951 arg3 = static_cast< double >(val3);
18952 }
18953 if (obj3) {
18954 ecode4 = SWIG_AsVal_double(obj3, &val4);
18955 if (!SWIG_IsOK(ecode4)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18957 }
18958 arg4 = static_cast< double >(val4);
18959 }
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj = 0;
18975 wxImage *arg1 = (wxImage *) 0 ;
18976 byte arg2 ;
18977 byte arg3 ;
18978 byte arg4 ;
18979 SwigValueWrapper<wxImage > result;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 unsigned char val2 ;
18983 int ecode2 = 0 ;
18984 unsigned char val3 ;
18985 int ecode3 = 0 ;
18986 unsigned char val4 ;
18987 int ecode4 = 0 ;
18988 PyObject * obj0 = 0 ;
18989 PyObject * obj1 = 0 ;
18990 PyObject * obj2 = 0 ;
18991 PyObject * obj3 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19000 }
19001 arg1 = reinterpret_cast< wxImage * >(argp1);
19002 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19003 if (!SWIG_IsOK(ecode2)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19005 }
19006 arg2 = static_cast< byte >(val2);
19007 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19008 if (!SWIG_IsOK(ecode3)) {
19009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19010 }
19011 arg3 = static_cast< byte >(val3);
19012 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19013 if (!SWIG_IsOK(ecode4)) {
19014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19015 }
19016 arg4 = static_cast< byte >(val4);
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj = 0;
19032 wxImage *arg1 = (wxImage *) 0 ;
19033 wxString *arg2 = 0 ;
19034 wxString *arg3 = 0 ;
19035 void *argp1 = 0 ;
19036 int res1 = 0 ;
19037 bool temp2 = false ;
19038 bool temp3 = false ;
19039 PyObject * obj0 = 0 ;
19040 PyObject * obj1 = 0 ;
19041 PyObject * obj2 = 0 ;
19042 char * kwnames[] = {
19043 (char *) "self",(char *) "name",(char *) "value", NULL
19044 };
19045
19046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19050 }
19051 arg1 = reinterpret_cast< wxImage * >(argp1);
19052 {
19053 arg2 = wxString_in_helper(obj1);
19054 if (arg2 == NULL) SWIG_fail;
19055 temp2 = true;
19056 }
19057 {
19058 arg3 = wxString_in_helper(obj2);
19059 if (arg3 == NULL) SWIG_fail;
19060 temp3 = true;
19061 }
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19065 wxPyEndAllowThreads(__tstate);
19066 if (PyErr_Occurred()) SWIG_fail;
19067 }
19068 resultobj = SWIG_Py_Void();
19069 {
19070 if (temp2)
19071 delete arg2;
19072 }
19073 {
19074 if (temp3)
19075 delete arg3;
19076 }
19077 return resultobj;
19078 fail:
19079 {
19080 if (temp2)
19081 delete arg2;
19082 }
19083 {
19084 if (temp3)
19085 delete arg3;
19086 }
19087 return NULL;
19088 }
19089
19090
19091 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj = 0;
19093 wxImage *arg1 = (wxImage *) 0 ;
19094 wxString *arg2 = 0 ;
19095 int arg3 ;
19096 void *argp1 = 0 ;
19097 int res1 = 0 ;
19098 bool temp2 = false ;
19099 int val3 ;
19100 int ecode3 = 0 ;
19101 PyObject * obj0 = 0 ;
19102 PyObject * obj1 = 0 ;
19103 PyObject * obj2 = 0 ;
19104 char * kwnames[] = {
19105 (char *) "self",(char *) "name",(char *) "value", NULL
19106 };
19107
19108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19112 }
19113 arg1 = reinterpret_cast< wxImage * >(argp1);
19114 {
19115 arg2 = wxString_in_helper(obj1);
19116 if (arg2 == NULL) SWIG_fail;
19117 temp2 = true;
19118 }
19119 ecode3 = SWIG_AsVal_int(obj2, &val3);
19120 if (!SWIG_IsOK(ecode3)) {
19121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19122 }
19123 arg3 = static_cast< int >(val3);
19124 {
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 (arg1)->SetOption((wxString const &)*arg2,arg3);
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 resultobj = SWIG_Py_Void();
19131 {
19132 if (temp2)
19133 delete arg2;
19134 }
19135 return resultobj;
19136 fail:
19137 {
19138 if (temp2)
19139 delete arg2;
19140 }
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj = 0;
19147 wxImage *arg1 = (wxImage *) 0 ;
19148 wxString *arg2 = 0 ;
19149 wxString result;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 bool temp2 = false ;
19153 PyObject * obj0 = 0 ;
19154 PyObject * obj1 = 0 ;
19155 char * kwnames[] = {
19156 (char *) "self",(char *) "name", NULL
19157 };
19158
19159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19163 }
19164 arg1 = reinterpret_cast< wxImage * >(argp1);
19165 {
19166 arg2 = wxString_in_helper(obj1);
19167 if (arg2 == NULL) SWIG_fail;
19168 temp2 = true;
19169 }
19170 {
19171 PyThreadState* __tstate = wxPyBeginAllowThreads();
19172 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19173 wxPyEndAllowThreads(__tstate);
19174 if (PyErr_Occurred()) SWIG_fail;
19175 }
19176 {
19177 #if wxUSE_UNICODE
19178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19179 #else
19180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19181 #endif
19182 }
19183 {
19184 if (temp2)
19185 delete arg2;
19186 }
19187 return resultobj;
19188 fail:
19189 {
19190 if (temp2)
19191 delete arg2;
19192 }
19193 return NULL;
19194 }
19195
19196
19197 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = 0;
19199 wxImage *arg1 = (wxImage *) 0 ;
19200 wxString *arg2 = 0 ;
19201 int result;
19202 void *argp1 = 0 ;
19203 int res1 = 0 ;
19204 bool temp2 = false ;
19205 PyObject * obj0 = 0 ;
19206 PyObject * obj1 = 0 ;
19207 char * kwnames[] = {
19208 (char *) "self",(char *) "name", NULL
19209 };
19210
19211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19215 }
19216 arg1 = reinterpret_cast< wxImage * >(argp1);
19217 {
19218 arg2 = wxString_in_helper(obj1);
19219 if (arg2 == NULL) SWIG_fail;
19220 temp2 = true;
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 resultobj = SWIG_From_int(static_cast< int >(result));
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_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj = 0;
19245 wxImage *arg1 = (wxImage *) 0 ;
19246 wxString *arg2 = 0 ;
19247 bool result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 bool temp2 = false ;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char * kwnames[] = {
19254 (char *) "self",(char *) "name", NULL
19255 };
19256
19257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19259 if (!SWIG_IsOK(res1)) {
19260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19261 }
19262 arg1 = reinterpret_cast< wxImage * >(argp1);
19263 {
19264 arg2 = wxString_in_helper(obj1);
19265 if (arg2 == NULL) SWIG_fail;
19266 temp2 = true;
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19271 wxPyEndAllowThreads(__tstate);
19272 if (PyErr_Occurred()) SWIG_fail;
19273 }
19274 {
19275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19276 }
19277 {
19278 if (temp2)
19279 delete arg2;
19280 }
19281 return resultobj;
19282 fail:
19283 {
19284 if (temp2)
19285 delete arg2;
19286 }
19287 return NULL;
19288 }
19289
19290
19291 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19292 PyObject *resultobj = 0;
19293 wxImage *arg1 = (wxImage *) 0 ;
19294 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19295 unsigned long result;
19296 void *argp1 = 0 ;
19297 int res1 = 0 ;
19298 unsigned long val2 ;
19299 int ecode2 = 0 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 char * kwnames[] = {
19303 (char *) "self",(char *) "stopafter", NULL
19304 };
19305
19306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19308 if (!SWIG_IsOK(res1)) {
19309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19310 }
19311 arg1 = reinterpret_cast< wxImage * >(argp1);
19312 if (obj1) {
19313 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19314 if (!SWIG_IsOK(ecode2)) {
19315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19316 }
19317 arg2 = static_cast< unsigned long >(val2);
19318 }
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 result = (unsigned long)(arg1)->CountColours(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj = 0;
19334 wxImage *arg1 = (wxImage *) 0 ;
19335 wxImageHistogram *arg2 = 0 ;
19336 unsigned long result;
19337 void *argp1 = 0 ;
19338 int res1 = 0 ;
19339 void *argp2 = 0 ;
19340 int res2 = 0 ;
19341 PyObject * obj0 = 0 ;
19342 PyObject * obj1 = 0 ;
19343 char * kwnames[] = {
19344 (char *) "self",(char *) "h", NULL
19345 };
19346
19347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19349 if (!SWIG_IsOK(res1)) {
19350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19351 }
19352 arg1 = reinterpret_cast< wxImage * >(argp1);
19353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19354 if (!SWIG_IsOK(res2)) {
19355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19356 }
19357 if (!argp2) {
19358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19359 }
19360 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj = 0;
19376 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19377 void *argp1 = 0 ;
19378 int res1 = 0 ;
19379 PyObject * obj0 = 0 ;
19380 char * kwnames[] = {
19381 (char *) "handler", NULL
19382 };
19383
19384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19386 if (!SWIG_IsOK(res1)) {
19387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19388 }
19389 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 wxImage::AddHandler(arg1);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_Py_Void();
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19406 void *argp1 = 0 ;
19407 int res1 = 0 ;
19408 PyObject * obj0 = 0 ;
19409 char * kwnames[] = {
19410 (char *) "handler", NULL
19411 };
19412
19413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19415 if (!SWIG_IsOK(res1)) {
19416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19417 }
19418 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19419 {
19420 PyThreadState* __tstate = wxPyBeginAllowThreads();
19421 wxImage::InsertHandler(arg1);
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 resultobj = SWIG_Py_Void();
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj = 0;
19434 wxString *arg1 = 0 ;
19435 bool result;
19436 bool temp1 = false ;
19437 PyObject * obj0 = 0 ;
19438 char * kwnames[] = {
19439 (char *) "name", NULL
19440 };
19441
19442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19443 {
19444 arg1 = wxString_in_helper(obj0);
19445 if (arg1 == NULL) SWIG_fail;
19446 temp1 = true;
19447 }
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 {
19455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19456 }
19457 {
19458 if (temp1)
19459 delete arg1;
19460 }
19461 return resultobj;
19462 fail:
19463 {
19464 if (temp1)
19465 delete arg1;
19466 }
19467 return NULL;
19468 }
19469
19470
19471 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19472 PyObject *resultobj = 0;
19473 PyObject *result = 0 ;
19474
19475 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 result = (PyObject *)wxImage_GetHandlers();
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = result;
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 PyObject *resultobj = 0;
19491 wxString result;
19492
19493 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = wxImage::GetImageExtWildcard();
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 {
19501 #if wxUSE_UNICODE
19502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19503 #else
19504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19505 #endif
19506 }
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19514 PyObject *resultobj = 0;
19515 wxImage *arg1 = (wxImage *) 0 ;
19516 int arg2 = (int) -1 ;
19517 wxBitmap result;
19518 void *argp1 = 0 ;
19519 int res1 = 0 ;
19520 int val2 ;
19521 int ecode2 = 0 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "self",(char *) "depth", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19530 if (!SWIG_IsOK(res1)) {
19531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19532 }
19533 arg1 = reinterpret_cast< wxImage * >(argp1);
19534 if (obj1) {
19535 ecode2 = SWIG_AsVal_int(obj1, &val2);
19536 if (!SWIG_IsOK(ecode2)) {
19537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19538 }
19539 arg2 = static_cast< int >(val2);
19540 }
19541 {
19542 if (!wxPyCheckForApp()) SWIG_fail;
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = wxImage_ConvertToBitmap(arg1,arg2);
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj = 0;
19557 wxImage *arg1 = (wxImage *) 0 ;
19558 byte arg2 ;
19559 byte arg3 ;
19560 byte arg4 ;
19561 wxBitmap result;
19562 void *argp1 = 0 ;
19563 int res1 = 0 ;
19564 unsigned char val2 ;
19565 int ecode2 = 0 ;
19566 unsigned char val3 ;
19567 int ecode3 = 0 ;
19568 unsigned char val4 ;
19569 int ecode4 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 PyObject * obj2 = 0 ;
19573 PyObject * obj3 = 0 ;
19574 char * kwnames[] = {
19575 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19576 };
19577
19578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19580 if (!SWIG_IsOK(res1)) {
19581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19582 }
19583 arg1 = reinterpret_cast< wxImage * >(argp1);
19584 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19585 if (!SWIG_IsOK(ecode2)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19587 }
19588 arg2 = static_cast< byte >(val2);
19589 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19590 if (!SWIG_IsOK(ecode3)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19592 }
19593 arg3 = static_cast< byte >(val3);
19594 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19595 if (!SWIG_IsOK(ecode4)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19597 }
19598 arg4 = static_cast< byte >(val4);
19599 {
19600 if (!wxPyCheckForApp()) SWIG_fail;
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19614 PyObject *resultobj = 0;
19615 wxImage *arg1 = (wxImage *) 0 ;
19616 double arg2 ;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 double val2 ;
19620 int ecode2 = 0 ;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 char * kwnames[] = {
19624 (char *) "self",(char *) "angle", NULL
19625 };
19626
19627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19629 if (!SWIG_IsOK(res1)) {
19630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19631 }
19632 arg1 = reinterpret_cast< wxImage * >(argp1);
19633 ecode2 = SWIG_AsVal_double(obj1, &val2);
19634 if (!SWIG_IsOK(ecode2)) {
19635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19636 }
19637 arg2 = static_cast< double >(val2);
19638 {
19639 PyThreadState* __tstate = wxPyBeginAllowThreads();
19640 (arg1)->RotateHue(arg2);
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 resultobj = SWIG_Py_Void();
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj = 0;
19653 wxImage_RGBValue arg1 ;
19654 wxImage_HSVValue result;
19655 void *argp1 ;
19656 int res1 = 0 ;
19657 PyObject * obj0 = 0 ;
19658 char * kwnames[] = {
19659 (char *) "rgb", NULL
19660 };
19661
19662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19663 {
19664 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19665 if (!SWIG_IsOK(res1)) {
19666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19667 }
19668 if (!argp1) {
19669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19670 } else {
19671 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19672 arg1 = *temp;
19673 if (SWIG_IsNewObj(res1)) delete temp;
19674 }
19675 }
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = wxImage::RGBtoHSV(arg1);
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19690 PyObject *resultobj = 0;
19691 wxImage_HSVValue arg1 ;
19692 wxImage_RGBValue result;
19693 void *argp1 ;
19694 int res1 = 0 ;
19695 PyObject * obj0 = 0 ;
19696 char * kwnames[] = {
19697 (char *) "hsv", NULL
19698 };
19699
19700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19701 {
19702 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19703 if (!SWIG_IsOK(res1)) {
19704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19705 }
19706 if (!argp1) {
19707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19708 } else {
19709 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19710 arg1 = *temp;
19711 if (SWIG_IsNewObj(res1)) delete temp;
19712 }
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = wxImage::HSVtoRGB(arg1);
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *obj;
19729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19730 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19731 return SWIG_Py_Void();
19732 }
19733
19734 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19735 return SWIG_Python_InitShadowInstance(args);
19736 }
19737
19738 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = 0;
19740 int arg1 ;
19741 int arg2 ;
19742 buffer arg3 ;
19743 int arg4 ;
19744 buffer arg5 = (buffer) NULL ;
19745 int arg6 = (int) 0 ;
19746 wxImage *result = 0 ;
19747 int val1 ;
19748 int ecode1 = 0 ;
19749 int val2 ;
19750 int ecode2 = 0 ;
19751 Py_ssize_t temp3 ;
19752 Py_ssize_t temp5 ;
19753 PyObject * obj0 = 0 ;
19754 PyObject * obj1 = 0 ;
19755 PyObject * obj2 = 0 ;
19756 PyObject * obj3 = 0 ;
19757 char * kwnames[] = {
19758 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19759 };
19760
19761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19762 ecode1 = SWIG_AsVal_int(obj0, &val1);
19763 if (!SWIG_IsOK(ecode1)) {
19764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19765 }
19766 arg1 = static_cast< int >(val1);
19767 ecode2 = SWIG_AsVal_int(obj1, &val2);
19768 if (!SWIG_IsOK(ecode2)) {
19769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19770 }
19771 arg2 = static_cast< int >(val2);
19772 {
19773 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19774 arg4 = (int)temp3;
19775 }
19776 if (obj3) {
19777 {
19778 if (obj3 != Py_None) {
19779 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19780 arg6 = (int)temp5;
19781 }
19782 }
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19792 }
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN int NullImage_set(PyObject *) {
19800 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19801 return 1;
19802 }
19803
19804
19805 SWIGINTERN PyObject *NullImage_get(void) {
19806 PyObject *pyobj = 0;
19807
19808 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19809 return pyobj;
19810 }
19811
19812
19813 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19814 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19815 return 1;
19816 }
19817
19818
19819 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19820 PyObject *pyobj = 0;
19821
19822 {
19823 #if wxUSE_UNICODE
19824 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19825 #else
19826 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19827 #endif
19828 }
19829 return pyobj;
19830 }
19831
19832
19833 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19834 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19835 return 1;
19836 }
19837
19838
19839 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19840 PyObject *pyobj = 0;
19841
19842 {
19843 #if wxUSE_UNICODE
19844 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19845 #else
19846 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19847 #endif
19848 }
19849 return pyobj;
19850 }
19851
19852
19853 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19854 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19855 return 1;
19856 }
19857
19858
19859 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19860 PyObject *pyobj = 0;
19861
19862 {
19863 #if wxUSE_UNICODE
19864 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19865 #else
19866 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19867 #endif
19868 }
19869 return pyobj;
19870 }
19871
19872
19873 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19874 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19875 return 1;
19876 }
19877
19878
19879 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19880 PyObject *pyobj = 0;
19881
19882 {
19883 #if wxUSE_UNICODE
19884 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19885 #else
19886 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19887 #endif
19888 }
19889 return pyobj;
19890 }
19891
19892
19893 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19894 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19895 return 1;
19896 }
19897
19898
19899 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19900 PyObject *pyobj = 0;
19901
19902 {
19903 #if wxUSE_UNICODE
19904 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19905 #else
19906 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19907 #endif
19908 }
19909 return pyobj;
19910 }
19911
19912
19913 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19914 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19915 return 1;
19916 }
19917
19918
19919 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19920 PyObject *pyobj = 0;
19921
19922 {
19923 #if wxUSE_UNICODE
19924 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19925 #else
19926 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19927 #endif
19928 }
19929 return pyobj;
19930 }
19931
19932
19933 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19934 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19935 return 1;
19936 }
19937
19938
19939 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19940 PyObject *pyobj = 0;
19941
19942 {
19943 #if wxUSE_UNICODE
19944 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19945 #else
19946 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19947 #endif
19948 }
19949 return pyobj;
19950 }
19951
19952
19953 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19954 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19955 return 1;
19956 }
19957
19958
19959 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19960 PyObject *pyobj = 0;
19961
19962 {
19963 #if wxUSE_UNICODE
19964 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19965 #else
19966 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19967 #endif
19968 }
19969 return pyobj;
19970 }
19971
19972
19973 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19974 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19975 return 1;
19976 }
19977
19978
19979 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19980 PyObject *pyobj = 0;
19981
19982 {
19983 #if wxUSE_UNICODE
19984 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19985 #else
19986 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19987 #endif
19988 }
19989 return pyobj;
19990 }
19991
19992
19993 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19994 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19995 return 1;
19996 }
19997
19998
19999 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20000 PyObject *pyobj = 0;
20001
20002 {
20003 #if wxUSE_UNICODE
20004 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20005 #else
20006 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20007 #endif
20008 }
20009 return pyobj;
20010 }
20011
20012
20013 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20014 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20015 return 1;
20016 }
20017
20018
20019 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20020 PyObject *pyobj = 0;
20021
20022 {
20023 #if wxUSE_UNICODE
20024 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20025 #else
20026 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20027 #endif
20028 }
20029 return pyobj;
20030 }
20031
20032
20033 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20034 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20035 return 1;
20036 }
20037
20038
20039 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20040 PyObject *pyobj = 0;
20041
20042 {
20043 #if wxUSE_UNICODE
20044 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20045 #else
20046 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20047 #endif
20048 }
20049 return pyobj;
20050 }
20051
20052
20053 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20054 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20055 return 1;
20056 }
20057
20058
20059 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20060 PyObject *pyobj = 0;
20061
20062 {
20063 #if wxUSE_UNICODE
20064 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20065 #else
20066 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20067 #endif
20068 }
20069 return pyobj;
20070 }
20071
20072
20073 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20074 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20075 return 1;
20076 }
20077
20078
20079 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20080 PyObject *pyobj = 0;
20081
20082 {
20083 #if wxUSE_UNICODE
20084 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20085 #else
20086 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20087 #endif
20088 }
20089 return pyobj;
20090 }
20091
20092
20093 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20094 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20095 return 1;
20096 }
20097
20098
20099 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20100 PyObject *pyobj = 0;
20101
20102 {
20103 #if wxUSE_UNICODE
20104 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20105 #else
20106 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20107 #endif
20108 }
20109 return pyobj;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxBMPHandler *result = 0 ;
20116
20117 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 result = (wxBMPHandler *)new wxBMPHandler();
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20132 PyObject *obj;
20133 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20134 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20135 return SWIG_Py_Void();
20136 }
20137
20138 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20139 return SWIG_Python_InitShadowInstance(args);
20140 }
20141
20142 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20143 PyObject *resultobj = 0;
20144 wxICOHandler *result = 0 ;
20145
20146 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (wxICOHandler *)new wxICOHandler();
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20161 PyObject *obj;
20162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20163 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20164 return SWIG_Py_Void();
20165 }
20166
20167 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20168 return SWIG_Python_InitShadowInstance(args);
20169 }
20170
20171 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20172 PyObject *resultobj = 0;
20173 wxCURHandler *result = 0 ;
20174
20175 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 result = (wxCURHandler *)new wxCURHandler();
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20190 PyObject *obj;
20191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20193 return SWIG_Py_Void();
20194 }
20195
20196 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20197 return SWIG_Python_InitShadowInstance(args);
20198 }
20199
20200 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201 PyObject *resultobj = 0;
20202 wxANIHandler *result = 0 ;
20203
20204 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20205 {
20206 PyThreadState* __tstate = wxPyBeginAllowThreads();
20207 result = (wxANIHandler *)new wxANIHandler();
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *obj;
20220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20221 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20222 return SWIG_Py_Void();
20223 }
20224
20225 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 return SWIG_Python_InitShadowInstance(args);
20227 }
20228
20229 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 wxPNGHandler *result = 0 ;
20232
20233 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (wxPNGHandler *)new wxPNGHandler();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *obj;
20249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20250 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20251 return SWIG_Py_Void();
20252 }
20253
20254 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 return SWIG_Python_InitShadowInstance(args);
20256 }
20257
20258 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *resultobj = 0;
20260 wxGIFHandler *result = 0 ;
20261
20262 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxGIFHandler *)new wxGIFHandler();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *obj;
20278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20279 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20280 return SWIG_Py_Void();
20281 }
20282
20283 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20284 return SWIG_Python_InitShadowInstance(args);
20285 }
20286
20287 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxPCXHandler *result = 0 ;
20290
20291 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (wxPCXHandler *)new wxPCXHandler();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20306 PyObject *obj;
20307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20308 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20309 return SWIG_Py_Void();
20310 }
20311
20312 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 return SWIG_Python_InitShadowInstance(args);
20314 }
20315
20316 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxJPEGHandler *result = 0 ;
20319
20320 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (wxJPEGHandler *)new wxJPEGHandler();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20335 PyObject *obj;
20336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20337 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20338 return SWIG_Py_Void();
20339 }
20340
20341 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 return SWIG_Python_InitShadowInstance(args);
20343 }
20344
20345 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *resultobj = 0;
20347 wxPNMHandler *result = 0 ;
20348
20349 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (wxPNMHandler *)new wxPNMHandler();
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *obj;
20365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20366 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20367 return SWIG_Py_Void();
20368 }
20369
20370 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 return SWIG_Python_InitShadowInstance(args);
20372 }
20373
20374 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxXPMHandler *result = 0 ;
20377
20378 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (wxXPMHandler *)new wxXPMHandler();
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *obj;
20394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20395 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20396 return SWIG_Py_Void();
20397 }
20398
20399 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 return SWIG_Python_InitShadowInstance(args);
20401 }
20402
20403 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *resultobj = 0;
20405 wxTIFFHandler *result = 0 ;
20406
20407 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxTIFFHandler *)new wxTIFFHandler();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *obj;
20423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20424 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20425 return SWIG_Py_Void();
20426 }
20427
20428 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 return SWIG_Python_InitShadowInstance(args);
20430 }
20431
20432 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxTGAHandler *result = 0 ;
20435
20436 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (wxTGAHandler *)new wxTGAHandler();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20451 PyObject *obj;
20452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20453 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20454 return SWIG_Py_Void();
20455 }
20456
20457 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 return SWIG_Python_InitShadowInstance(args);
20459 }
20460
20461 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20462 PyObject *resultobj = 0;
20463 wxImage *arg1 = 0 ;
20464 wxImage *arg2 = 0 ;
20465 int arg3 = (int) 236 ;
20466 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20467 bool result;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 void *argp2 = 0 ;
20471 int res2 = 0 ;
20472 int val3 ;
20473 int ecode3 = 0 ;
20474 int val4 ;
20475 int ecode4 = 0 ;
20476 PyObject * obj0 = 0 ;
20477 PyObject * obj1 = 0 ;
20478 PyObject * obj2 = 0 ;
20479 PyObject * obj3 = 0 ;
20480 char * kwnames[] = {
20481 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20482 };
20483
20484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20485 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20488 }
20489 if (!argp1) {
20490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20491 }
20492 arg1 = reinterpret_cast< wxImage * >(argp1);
20493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20494 if (!SWIG_IsOK(res2)) {
20495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20496 }
20497 if (!argp2) {
20498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20499 }
20500 arg2 = reinterpret_cast< wxImage * >(argp2);
20501 if (obj2) {
20502 ecode3 = SWIG_AsVal_int(obj2, &val3);
20503 if (!SWIG_IsOK(ecode3)) {
20504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20505 }
20506 arg3 = static_cast< int >(val3);
20507 }
20508 if (obj3) {
20509 ecode4 = SWIG_AsVal_int(obj3, &val4);
20510 if (!SWIG_IsOK(ecode4)) {
20511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20512 }
20513 arg4 = static_cast< int >(val4);
20514 }
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 {
20522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20523 }
20524 return resultobj;
20525 fail:
20526 return NULL;
20527 }
20528
20529
20530 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20531 PyObject *obj;
20532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20533 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20534 return SWIG_Py_Void();
20535 }
20536
20537 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxEvtHandler *result = 0 ;
20540
20541 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (wxEvtHandler *)new wxEvtHandler();
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20549 return resultobj;
20550 fail:
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20556 PyObject *resultobj = 0;
20557 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20558 wxEvtHandler *result = 0 ;
20559 void *argp1 = 0 ;
20560 int res1 = 0 ;
20561 PyObject *swig_obj[1] ;
20562
20563 if (!args) SWIG_fail;
20564 swig_obj[0] = args;
20565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20568 }
20569 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20573 wxPyEndAllowThreads(__tstate);
20574 if (PyErr_Occurred()) SWIG_fail;
20575 }
20576 {
20577 resultobj = wxPyMake_wxObject(result, 0);
20578 }
20579 return resultobj;
20580 fail:
20581 return NULL;
20582 }
20583
20584
20585 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20586 PyObject *resultobj = 0;
20587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20588 wxEvtHandler *result = 0 ;
20589 void *argp1 = 0 ;
20590 int res1 = 0 ;
20591 PyObject *swig_obj[1] ;
20592
20593 if (!args) SWIG_fail;
20594 swig_obj[0] = args;
20595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20596 if (!SWIG_IsOK(res1)) {
20597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20598 }
20599 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20603 wxPyEndAllowThreads(__tstate);
20604 if (PyErr_Occurred()) SWIG_fail;
20605 }
20606 {
20607 resultobj = wxPyMake_wxObject(result, 0);
20608 }
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj = 0;
20617 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20618 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20619 void *argp1 = 0 ;
20620 int res1 = 0 ;
20621 void *argp2 = 0 ;
20622 int res2 = 0 ;
20623 PyObject * obj0 = 0 ;
20624 PyObject * obj1 = 0 ;
20625 char * kwnames[] = {
20626 (char *) "self",(char *) "handler", NULL
20627 };
20628
20629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20631 if (!SWIG_IsOK(res1)) {
20632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20633 }
20634 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20636 if (!SWIG_IsOK(res2)) {
20637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20638 }
20639 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 (arg1)->SetNextHandler(arg2);
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 resultobj = SWIG_Py_Void();
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20654 PyObject *resultobj = 0;
20655 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20656 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20657 void *argp1 = 0 ;
20658 int res1 = 0 ;
20659 void *argp2 = 0 ;
20660 int res2 = 0 ;
20661 PyObject * obj0 = 0 ;
20662 PyObject * obj1 = 0 ;
20663 char * kwnames[] = {
20664 (char *) "self",(char *) "handler", NULL
20665 };
20666
20667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20669 if (!SWIG_IsOK(res1)) {
20670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20671 }
20672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20674 if (!SWIG_IsOK(res2)) {
20675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20676 }
20677 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 (arg1)->SetPreviousHandler(arg2);
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 resultobj = SWIG_Py_Void();
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20692 PyObject *resultobj = 0;
20693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20694 bool result;
20695 void *argp1 = 0 ;
20696 int res1 = 0 ;
20697 PyObject *swig_obj[1] ;
20698
20699 if (!args) SWIG_fail;
20700 swig_obj[0] = args;
20701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20704 }
20705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = (bool)(arg1)->GetEvtHandlerEnabled();
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 {
20713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20714 }
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20722 PyObject *resultobj = 0;
20723 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20724 bool arg2 ;
20725 void *argp1 = 0 ;
20726 int res1 = 0 ;
20727 bool val2 ;
20728 int ecode2 = 0 ;
20729 PyObject * obj0 = 0 ;
20730 PyObject * obj1 = 0 ;
20731 char * kwnames[] = {
20732 (char *) "self",(char *) "enabled", NULL
20733 };
20734
20735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20739 }
20740 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20742 if (!SWIG_IsOK(ecode2)) {
20743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20744 }
20745 arg2 = static_cast< bool >(val2);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 (arg1)->SetEvtHandlerEnabled(arg2);
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 resultobj = SWIG_Py_Void();
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj = 0;
20761 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20762 wxEvent *arg2 = 0 ;
20763 bool result;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 void *argp2 = 0 ;
20767 int res2 = 0 ;
20768 PyObject * obj0 = 0 ;
20769 PyObject * obj1 = 0 ;
20770 char * kwnames[] = {
20771 (char *) "self",(char *) "event", NULL
20772 };
20773
20774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20776 if (!SWIG_IsOK(res1)) {
20777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20778 }
20779 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20780 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20781 if (!SWIG_IsOK(res2)) {
20782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20783 }
20784 if (!argp2) {
20785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20786 }
20787 arg2 = reinterpret_cast< wxEvent * >(argp2);
20788 {
20789 PyThreadState* __tstate = wxPyBeginAllowThreads();
20790 result = (bool)(arg1)->ProcessEvent(*arg2);
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 {
20795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20796 }
20797 return resultobj;
20798 fail:
20799 return NULL;
20800 }
20801
20802
20803 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20804 PyObject *resultobj = 0;
20805 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20806 wxEvent *arg2 = 0 ;
20807 void *argp1 = 0 ;
20808 int res1 = 0 ;
20809 void *argp2 = 0 ;
20810 int res2 = 0 ;
20811 PyObject * obj0 = 0 ;
20812 PyObject * obj1 = 0 ;
20813 char * kwnames[] = {
20814 (char *) "self",(char *) "event", NULL
20815 };
20816
20817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20821 }
20822 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20824 if (!SWIG_IsOK(res2)) {
20825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20826 }
20827 if (!argp2) {
20828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20829 }
20830 arg2 = reinterpret_cast< wxEvent * >(argp2);
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 (arg1)->AddPendingEvent(*arg2);
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 resultobj = SWIG_Py_Void();
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20845 PyObject *resultobj = 0;
20846 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20847 void *argp1 = 0 ;
20848 int res1 = 0 ;
20849 PyObject *swig_obj[1] ;
20850
20851 if (!args) SWIG_fail;
20852 swig_obj[0] = args;
20853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20854 if (!SWIG_IsOK(res1)) {
20855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20856 }
20857 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 (arg1)->ProcessPendingEvents();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_Py_Void();
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj = 0;
20873 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20874 int arg2 ;
20875 int arg3 ;
20876 int arg4 ;
20877 PyObject *arg5 = (PyObject *) 0 ;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 int val2 ;
20881 int ecode2 = 0 ;
20882 int val3 ;
20883 int ecode3 = 0 ;
20884 int val4 ;
20885 int ecode4 = 0 ;
20886 PyObject * obj0 = 0 ;
20887 PyObject * obj1 = 0 ;
20888 PyObject * obj2 = 0 ;
20889 PyObject * obj3 = 0 ;
20890 PyObject * obj4 = 0 ;
20891 char * kwnames[] = {
20892 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20893 };
20894
20895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20899 }
20900 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20901 ecode2 = SWIG_AsVal_int(obj1, &val2);
20902 if (!SWIG_IsOK(ecode2)) {
20903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20904 }
20905 arg2 = static_cast< int >(val2);
20906 ecode3 = SWIG_AsVal_int(obj2, &val3);
20907 if (!SWIG_IsOK(ecode3)) {
20908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20909 }
20910 arg3 = static_cast< int >(val3);
20911 ecode4 = SWIG_AsVal_int(obj3, &val4);
20912 if (!SWIG_IsOK(ecode4)) {
20913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20914 }
20915 arg4 = static_cast< int >(val4);
20916 arg5 = obj4;
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_Py_Void();
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20931 PyObject *resultobj = 0;
20932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20933 int arg2 ;
20934 int arg3 = (int) -1 ;
20935 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20936 bool result;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 int val2 ;
20940 int ecode2 = 0 ;
20941 int val3 ;
20942 int ecode3 = 0 ;
20943 int val4 ;
20944 int ecode4 = 0 ;
20945 PyObject * obj0 = 0 ;
20946 PyObject * obj1 = 0 ;
20947 PyObject * obj2 = 0 ;
20948 PyObject * obj3 = 0 ;
20949 char * kwnames[] = {
20950 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20951 };
20952
20953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20955 if (!SWIG_IsOK(res1)) {
20956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20957 }
20958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20959 ecode2 = SWIG_AsVal_int(obj1, &val2);
20960 if (!SWIG_IsOK(ecode2)) {
20961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20962 }
20963 arg2 = static_cast< int >(val2);
20964 if (obj2) {
20965 ecode3 = SWIG_AsVal_int(obj2, &val3);
20966 if (!SWIG_IsOK(ecode3)) {
20967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20968 }
20969 arg3 = static_cast< int >(val3);
20970 }
20971 if (obj3) {
20972 ecode4 = SWIG_AsVal_int(obj3, &val4);
20973 if (!SWIG_IsOK(ecode4)) {
20974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20975 }
20976 arg4 = static_cast< wxEventType >(val4);
20977 }
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 {
20985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20986 }
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj = 0;
20995 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20996 PyObject *arg2 = (PyObject *) 0 ;
20997 bool arg3 = (bool) true ;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 bool val3 ;
21001 int ecode3 = 0 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 PyObject * obj2 = 0 ;
21005 char * kwnames[] = {
21006 (char *) "self",(char *) "_self",(char *) "incref", NULL
21007 };
21008
21009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21013 }
21014 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21015 arg2 = obj1;
21016 if (obj2) {
21017 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21018 if (!SWIG_IsOK(ecode3)) {
21019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21020 }
21021 arg3 = static_cast< bool >(val3);
21022 }
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21026 wxPyEndAllowThreads(__tstate);
21027 if (PyErr_Occurred()) SWIG_fail;
21028 }
21029 resultobj = SWIG_Py_Void();
21030 return resultobj;
21031 fail:
21032 return NULL;
21033 }
21034
21035
21036 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21037 PyObject *obj;
21038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21039 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21040 return SWIG_Py_Void();
21041 }
21042
21043 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 return SWIG_Python_InitShadowInstance(args);
21045 }
21046
21047 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxEventType result;
21050
21051 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (wxEventType)wxNewEventType();
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = SWIG_From_int(static_cast< int >(result));
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21066 PyObject *resultobj = 0;
21067 wxEvent *arg1 = (wxEvent *) 0 ;
21068 void *argp1 = 0 ;
21069 int res1 = 0 ;
21070 PyObject *swig_obj[1] ;
21071
21072 if (!args) SWIG_fail;
21073 swig_obj[0] = args;
21074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21075 if (!SWIG_IsOK(res1)) {
21076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21077 }
21078 arg1 = reinterpret_cast< wxEvent * >(argp1);
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 delete arg1;
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 resultobj = SWIG_Py_Void();
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj = 0;
21095 wxEvent *arg1 = (wxEvent *) 0 ;
21096 wxEventType arg2 ;
21097 void *argp1 = 0 ;
21098 int res1 = 0 ;
21099 int val2 ;
21100 int ecode2 = 0 ;
21101 PyObject * obj0 = 0 ;
21102 PyObject * obj1 = 0 ;
21103 char * kwnames[] = {
21104 (char *) "self",(char *) "typ", NULL
21105 };
21106
21107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21111 }
21112 arg1 = reinterpret_cast< wxEvent * >(argp1);
21113 ecode2 = SWIG_AsVal_int(obj1, &val2);
21114 if (!SWIG_IsOK(ecode2)) {
21115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21116 }
21117 arg2 = static_cast< wxEventType >(val2);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 (arg1)->SetEventType(arg2);
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_Py_Void();
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxEvent *arg1 = (wxEvent *) 0 ;
21134 wxEventType result;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxEvent * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 resultobj = SWIG_From_int(static_cast< int >(result));
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 PyObject *resultobj = 0;
21161 wxEvent *arg1 = (wxEvent *) 0 ;
21162 wxObject *result = 0 ;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 PyObject *swig_obj[1] ;
21166
21167 if (!args) SWIG_fail;
21168 swig_obj[0] = args;
21169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21172 }
21173 arg1 = reinterpret_cast< wxEvent * >(argp1);
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 {
21181 resultobj = wxPyMake_wxObject(result, (bool)0);
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj = 0;
21191 wxEvent *arg1 = (wxEvent *) 0 ;
21192 wxObject *arg2 = (wxObject *) 0 ;
21193 void *argp1 = 0 ;
21194 int res1 = 0 ;
21195 void *argp2 = 0 ;
21196 int res2 = 0 ;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 char * kwnames[] = {
21200 (char *) "self",(char *) "obj", NULL
21201 };
21202
21203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21205 if (!SWIG_IsOK(res1)) {
21206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21207 }
21208 arg1 = reinterpret_cast< wxEvent * >(argp1);
21209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21210 if (!SWIG_IsOK(res2)) {
21211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21212 }
21213 arg2 = reinterpret_cast< wxObject * >(argp2);
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 (arg1)->SetEventObject(arg2);
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxEvent *arg1 = (wxEvent *) 0 ;
21230 long result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21240 }
21241 arg1 = reinterpret_cast< wxEvent * >(argp1);
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 resultobj = SWIG_From_long(static_cast< long >(result));
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21256 PyObject *resultobj = 0;
21257 wxEvent *arg1 = (wxEvent *) 0 ;
21258 long arg2 = (long) 0 ;
21259 void *argp1 = 0 ;
21260 int res1 = 0 ;
21261 long val2 ;
21262 int ecode2 = 0 ;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char * kwnames[] = {
21266 (char *) "self",(char *) "ts", NULL
21267 };
21268
21269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21273 }
21274 arg1 = reinterpret_cast< wxEvent * >(argp1);
21275 if (obj1) {
21276 ecode2 = SWIG_AsVal_long(obj1, &val2);
21277 if (!SWIG_IsOK(ecode2)) {
21278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21279 }
21280 arg2 = static_cast< long >(val2);
21281 }
21282 {
21283 PyThreadState* __tstate = wxPyBeginAllowThreads();
21284 (arg1)->SetTimestamp(arg2);
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 resultobj = SWIG_Py_Void();
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxEvent *arg1 = (wxEvent *) 0 ;
21298 int result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 PyObject *swig_obj[1] ;
21302
21303 if (!args) SWIG_fail;
21304 swig_obj[0] = args;
21305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21306 if (!SWIG_IsOK(res1)) {
21307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21308 }
21309 arg1 = reinterpret_cast< wxEvent * >(argp1);
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (int)((wxEvent const *)arg1)->GetId();
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 resultobj = SWIG_From_int(static_cast< int >(result));
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj = 0;
21325 wxEvent *arg1 = (wxEvent *) 0 ;
21326 int arg2 ;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 int val2 ;
21330 int ecode2 = 0 ;
21331 PyObject * obj0 = 0 ;
21332 PyObject * obj1 = 0 ;
21333 char * kwnames[] = {
21334 (char *) "self",(char *) "Id", NULL
21335 };
21336
21337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21339 if (!SWIG_IsOK(res1)) {
21340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21341 }
21342 arg1 = reinterpret_cast< wxEvent * >(argp1);
21343 ecode2 = SWIG_AsVal_int(obj1, &val2);
21344 if (!SWIG_IsOK(ecode2)) {
21345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21346 }
21347 arg2 = static_cast< int >(val2);
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 (arg1)->SetId(arg2);
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_Py_Void();
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxEvent *arg1 = (wxEvent *) 0 ;
21364 bool result;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 PyObject *swig_obj[1] ;
21368
21369 if (!args) SWIG_fail;
21370 swig_obj[0] = args;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21374 }
21375 arg1 = reinterpret_cast< wxEvent * >(argp1);
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 {
21383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21384 }
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj = 0;
21393 wxEvent *arg1 = (wxEvent *) 0 ;
21394 bool arg2 = (bool) true ;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 bool val2 ;
21398 int ecode2 = 0 ;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char * kwnames[] = {
21402 (char *) "self",(char *) "skip", NULL
21403 };
21404
21405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21407 if (!SWIG_IsOK(res1)) {
21408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21409 }
21410 arg1 = reinterpret_cast< wxEvent * >(argp1);
21411 if (obj1) {
21412 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21413 if (!SWIG_IsOK(ecode2)) {
21414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21415 }
21416 arg2 = static_cast< bool >(val2);
21417 }
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 (arg1)->Skip(arg2);
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 resultobj = SWIG_Py_Void();
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21432 PyObject *resultobj = 0;
21433 wxEvent *arg1 = (wxEvent *) 0 ;
21434 bool result;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 PyObject *swig_obj[1] ;
21438
21439 if (!args) SWIG_fail;
21440 swig_obj[0] = args;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21444 }
21445 arg1 = reinterpret_cast< wxEvent * >(argp1);
21446 {
21447 PyThreadState* __tstate = wxPyBeginAllowThreads();
21448 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21449 wxPyEndAllowThreads(__tstate);
21450 if (PyErr_Occurred()) SWIG_fail;
21451 }
21452 {
21453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21454 }
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21462 PyObject *resultobj = 0;
21463 wxEvent *arg1 = (wxEvent *) 0 ;
21464 bool result;
21465 void *argp1 = 0 ;
21466 int res1 = 0 ;
21467 PyObject *swig_obj[1] ;
21468
21469 if (!args) SWIG_fail;
21470 swig_obj[0] = args;
21471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21472 if (!SWIG_IsOK(res1)) {
21473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21474 }
21475 arg1 = reinterpret_cast< wxEvent * >(argp1);
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21479 wxPyEndAllowThreads(__tstate);
21480 if (PyErr_Occurred()) SWIG_fail;
21481 }
21482 {
21483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21484 }
21485 return resultobj;
21486 fail:
21487 return NULL;
21488 }
21489
21490
21491 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21492 PyObject *resultobj = 0;
21493 wxEvent *arg1 = (wxEvent *) 0 ;
21494 int result;
21495 void *argp1 = 0 ;
21496 int res1 = 0 ;
21497 PyObject *swig_obj[1] ;
21498
21499 if (!args) SWIG_fail;
21500 swig_obj[0] = args;
21501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21502 if (!SWIG_IsOK(res1)) {
21503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21504 }
21505 arg1 = reinterpret_cast< wxEvent * >(argp1);
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (int)(arg1)->StopPropagation();
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 resultobj = SWIG_From_int(static_cast< int >(result));
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj = 0;
21521 wxEvent *arg1 = (wxEvent *) 0 ;
21522 int arg2 ;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 int val2 ;
21526 int ecode2 = 0 ;
21527 PyObject * obj0 = 0 ;
21528 PyObject * obj1 = 0 ;
21529 char * kwnames[] = {
21530 (char *) "self",(char *) "propagationLevel", NULL
21531 };
21532
21533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxEvent * >(argp1);
21539 ecode2 = SWIG_AsVal_int(obj1, &val2);
21540 if (!SWIG_IsOK(ecode2)) {
21541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21542 }
21543 arg2 = static_cast< int >(val2);
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 (arg1)->ResumePropagation(arg2);
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxEvent *arg1 = (wxEvent *) 0 ;
21560 wxEvent *result = 0 ;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxEvent * >(argp1);
21572 {
21573 PyThreadState* __tstate = wxPyBeginAllowThreads();
21574 result = (wxEvent *)(arg1)->Clone();
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21586 PyObject *obj;
21587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21588 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21589 return SWIG_Py_Void();
21590 }
21591
21592 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj = 0;
21594 wxEvent *arg1 = 0 ;
21595 wxPropagationDisabler *result = 0 ;
21596 void *argp1 = 0 ;
21597 int res1 = 0 ;
21598 PyObject * obj0 = 0 ;
21599 char * kwnames[] = {
21600 (char *) "event", NULL
21601 };
21602
21603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21604 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21605 if (!SWIG_IsOK(res1)) {
21606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21607 }
21608 if (!argp1) {
21609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21610 }
21611 arg1 = reinterpret_cast< wxEvent * >(argp1);
21612 {
21613 PyThreadState* __tstate = wxPyBeginAllowThreads();
21614 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21615 wxPyEndAllowThreads(__tstate);
21616 if (PyErr_Occurred()) SWIG_fail;
21617 }
21618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21619 return resultobj;
21620 fail:
21621 return NULL;
21622 }
21623
21624
21625 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21626 PyObject *resultobj = 0;
21627 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21628 void *argp1 = 0 ;
21629 int res1 = 0 ;
21630 PyObject *swig_obj[1] ;
21631
21632 if (!args) SWIG_fail;
21633 swig_obj[0] = args;
21634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21637 }
21638 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 delete arg1;
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_Py_Void();
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21654 PyObject *obj;
21655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21656 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21657 return SWIG_Py_Void();
21658 }
21659
21660 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661 return SWIG_Python_InitShadowInstance(args);
21662 }
21663
21664 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21665 PyObject *resultobj = 0;
21666 wxEvent *arg1 = 0 ;
21667 wxPropagateOnce *result = 0 ;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 PyObject * obj0 = 0 ;
21671 char * kwnames[] = {
21672 (char *) "event", NULL
21673 };
21674
21675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21676 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21679 }
21680 if (!argp1) {
21681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21682 }
21683 arg1 = reinterpret_cast< wxEvent * >(argp1);
21684 {
21685 PyThreadState* __tstate = wxPyBeginAllowThreads();
21686 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21687 wxPyEndAllowThreads(__tstate);
21688 if (PyErr_Occurred()) SWIG_fail;
21689 }
21690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21691 return resultobj;
21692 fail:
21693 return NULL;
21694 }
21695
21696
21697 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21698 PyObject *resultobj = 0;
21699 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21709 }
21710 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 delete arg1;
21714
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 resultobj = SWIG_Py_Void();
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *obj;
21727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21728 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21729 return SWIG_Py_Void();
21730 }
21731
21732 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 return SWIG_Python_InitShadowInstance(args);
21734 }
21735
21736 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21739 int arg2 = (int) 0 ;
21740 wxCommandEvent *result = 0 ;
21741 int val1 ;
21742 int ecode1 = 0 ;
21743 int val2 ;
21744 int ecode2 = 0 ;
21745 PyObject * obj0 = 0 ;
21746 PyObject * obj1 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "commandType",(char *) "winid", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21752 if (obj0) {
21753 ecode1 = SWIG_AsVal_int(obj0, &val1);
21754 if (!SWIG_IsOK(ecode1)) {
21755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21756 }
21757 arg1 = static_cast< wxEventType >(val1);
21758 }
21759 if (obj1) {
21760 ecode2 = SWIG_AsVal_int(obj1, &val2);
21761 if (!SWIG_IsOK(ecode2)) {
21762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21763 }
21764 arg2 = static_cast< int >(val2);
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21782 int result;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21792 }
21793 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 resultobj = SWIG_From_int(static_cast< int >(result));
21801 return resultobj;
21802 fail:
21803 return NULL;
21804 }
21805
21806
21807 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21808 PyObject *resultobj = 0;
21809 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21810 wxString *arg2 = 0 ;
21811 void *argp1 = 0 ;
21812 int res1 = 0 ;
21813 bool temp2 = false ;
21814 PyObject * obj0 = 0 ;
21815 PyObject * obj1 = 0 ;
21816 char * kwnames[] = {
21817 (char *) "self",(char *) "s", NULL
21818 };
21819
21820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21824 }
21825 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21826 {
21827 arg2 = wxString_in_helper(obj1);
21828 if (arg2 == NULL) SWIG_fail;
21829 temp2 = true;
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->SetString((wxString const &)*arg2);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_Py_Void();
21838 {
21839 if (temp2)
21840 delete arg2;
21841 }
21842 return resultobj;
21843 fail:
21844 {
21845 if (temp2)
21846 delete arg2;
21847 }
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 PyObject *resultobj = 0;
21854 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21855 wxString result;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 PyObject *swig_obj[1] ;
21859
21860 if (!args) SWIG_fail;
21861 swig_obj[0] = args;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21865 }
21866 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = ((wxCommandEvent const *)arg1)->GetString();
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 {
21874 #if wxUSE_UNICODE
21875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21876 #else
21877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21878 #endif
21879 }
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21889 bool result;
21890 void *argp1 = 0 ;
21891 int res1 = 0 ;
21892 PyObject *swig_obj[1] ;
21893
21894 if (!args) SWIG_fail;
21895 swig_obj[0] = args;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21899 }
21900 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21919 bool result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21929 }
21930 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21947 PyObject *resultobj = 0;
21948 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21949 long arg2 ;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 long val2 ;
21953 int ecode2 = 0 ;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char * kwnames[] = {
21957 (char *) "self",(char *) "extraLong", NULL
21958 };
21959
21960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21964 }
21965 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21966 ecode2 = SWIG_AsVal_long(obj1, &val2);
21967 if (!SWIG_IsOK(ecode2)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21969 }
21970 arg2 = static_cast< long >(val2);
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 (arg1)->SetExtraLong(arg2);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_Py_Void();
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21987 long result;
21988 void *argp1 = 0 ;
21989 int res1 = 0 ;
21990 PyObject *swig_obj[1] ;
21991
21992 if (!args) SWIG_fail;
21993 swig_obj[0] = args;
21994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21995 if (!SWIG_IsOK(res1)) {
21996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21997 }
21998 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 resultobj = SWIG_From_long(static_cast< long >(result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj = 0;
22014 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22015 int arg2 ;
22016 void *argp1 = 0 ;
22017 int res1 = 0 ;
22018 int val2 ;
22019 int ecode2 = 0 ;
22020 PyObject * obj0 = 0 ;
22021 PyObject * obj1 = 0 ;
22022 char * kwnames[] = {
22023 (char *) "self",(char *) "i", NULL
22024 };
22025
22026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22030 }
22031 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22032 ecode2 = SWIG_AsVal_int(obj1, &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22035 }
22036 arg2 = static_cast< int >(val2);
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 (arg1)->SetInt(arg2);
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22053 int result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22063 }
22064 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 resultobj = SWIG_From_int(static_cast< int >(result));
22072 return resultobj;
22073 fail:
22074 return NULL;
22075 }
22076
22077
22078 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22079 PyObject *resultobj = 0;
22080 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22081 PyObject *result = 0 ;
22082 void *argp1 = 0 ;
22083 int res1 = 0 ;
22084 PyObject *swig_obj[1] ;
22085
22086 if (!args) SWIG_fail;
22087 swig_obj[0] = args;
22088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22089 if (!SWIG_IsOK(res1)) {
22090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22091 }
22092 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 resultobj = result;
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj = 0;
22108 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22109 PyObject *arg2 = (PyObject *) 0 ;
22110 void *argp1 = 0 ;
22111 int res1 = 0 ;
22112 PyObject * obj0 = 0 ;
22113 PyObject * obj1 = 0 ;
22114 char * kwnames[] = {
22115 (char *) "self",(char *) "clientData", NULL
22116 };
22117
22118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22120 if (!SWIG_IsOK(res1)) {
22121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22122 }
22123 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22124 arg2 = obj1;
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 wxCommandEvent_SetClientData(arg1,arg2);
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 resultobj = SWIG_Py_Void();
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *resultobj = 0;
22140 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22141 wxEvent *result = 0 ;
22142 void *argp1 = 0 ;
22143 int res1 = 0 ;
22144 PyObject *swig_obj[1] ;
22145
22146 if (!args) SWIG_fail;
22147 swig_obj[0] = args;
22148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22149 if (!SWIG_IsOK(res1)) {
22150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22151 }
22152 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167 PyObject *obj;
22168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22169 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22170 return SWIG_Py_Void();
22171 }
22172
22173 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22174 return SWIG_Python_InitShadowInstance(args);
22175 }
22176
22177 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj = 0;
22179 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22180 int arg2 = (int) 0 ;
22181 wxNotifyEvent *result = 0 ;
22182 int val1 ;
22183 int ecode1 = 0 ;
22184 int val2 ;
22185 int ecode2 = 0 ;
22186 PyObject * obj0 = 0 ;
22187 PyObject * obj1 = 0 ;
22188 char * kwnames[] = {
22189 (char *) "commandType",(char *) "winid", NULL
22190 };
22191
22192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22193 if (obj0) {
22194 ecode1 = SWIG_AsVal_int(obj0, &val1);
22195 if (!SWIG_IsOK(ecode1)) {
22196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22197 }
22198 arg1 = static_cast< wxEventType >(val1);
22199 }
22200 if (obj1) {
22201 ecode2 = SWIG_AsVal_int(obj1, &val2);
22202 if (!SWIG_IsOK(ecode2)) {
22203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22204 }
22205 arg2 = static_cast< int >(val2);
22206 }
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22223 void *argp1 = 0 ;
22224 int res1 = 0 ;
22225 PyObject *swig_obj[1] ;
22226
22227 if (!args) SWIG_fail;
22228 swig_obj[0] = args;
22229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22230 if (!SWIG_IsOK(res1)) {
22231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22232 }
22233 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 (arg1)->Veto();
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 resultobj = SWIG_Py_Void();
22241 return resultobj;
22242 fail:
22243 return NULL;
22244 }
22245
22246
22247 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22248 PyObject *resultobj = 0;
22249 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22250 void *argp1 = 0 ;
22251 int res1 = 0 ;
22252 PyObject *swig_obj[1] ;
22253
22254 if (!args) SWIG_fail;
22255 swig_obj[0] = args;
22256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22257 if (!SWIG_IsOK(res1)) {
22258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22259 }
22260 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 (arg1)->Allow();
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 resultobj = SWIG_Py_Void();
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22275 PyObject *resultobj = 0;
22276 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22277 bool result;
22278 void *argp1 = 0 ;
22279 int res1 = 0 ;
22280 PyObject *swig_obj[1] ;
22281
22282 if (!args) SWIG_fail;
22283 swig_obj[0] = args;
22284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22285 if (!SWIG_IsOK(res1)) {
22286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22287 }
22288 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = (bool)(arg1)->IsAllowed();
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 {
22296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22297 }
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22305 PyObject *obj;
22306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22307 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22308 return SWIG_Py_Void();
22309 }
22310
22311 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 return SWIG_Python_InitShadowInstance(args);
22313 }
22314
22315 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22316 PyObject *resultobj = 0;
22317 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22318 int arg2 = (int) 0 ;
22319 int arg3 = (int) 0 ;
22320 int arg4 = (int) 0 ;
22321 wxScrollEvent *result = 0 ;
22322 int val1 ;
22323 int ecode1 = 0 ;
22324 int val2 ;
22325 int ecode2 = 0 ;
22326 int val3 ;
22327 int ecode3 = 0 ;
22328 int val4 ;
22329 int ecode4 = 0 ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 PyObject * obj2 = 0 ;
22333 PyObject * obj3 = 0 ;
22334 char * kwnames[] = {
22335 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22336 };
22337
22338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22339 if (obj0) {
22340 ecode1 = SWIG_AsVal_int(obj0, &val1);
22341 if (!SWIG_IsOK(ecode1)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22343 }
22344 arg1 = static_cast< wxEventType >(val1);
22345 }
22346 if (obj1) {
22347 ecode2 = SWIG_AsVal_int(obj1, &val2);
22348 if (!SWIG_IsOK(ecode2)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22350 }
22351 arg2 = static_cast< int >(val2);
22352 }
22353 if (obj2) {
22354 ecode3 = SWIG_AsVal_int(obj2, &val3);
22355 if (!SWIG_IsOK(ecode3)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22357 }
22358 arg3 = static_cast< int >(val3);
22359 }
22360 if (obj3) {
22361 ecode4 = SWIG_AsVal_int(obj3, &val4);
22362 if (!SWIG_IsOK(ecode4)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22364 }
22365 arg4 = static_cast< int >(val4);
22366 }
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22383 int result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22393 }
22394 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 resultobj = SWIG_From_int(static_cast< int >(result));
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22409 PyObject *resultobj = 0;
22410 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22411 int result;
22412 void *argp1 = 0 ;
22413 int res1 = 0 ;
22414 PyObject *swig_obj[1] ;
22415
22416 if (!args) SWIG_fail;
22417 swig_obj[0] = args;
22418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22419 if (!SWIG_IsOK(res1)) {
22420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22421 }
22422 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_From_int(static_cast< int >(result));
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22437 PyObject *resultobj = 0;
22438 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22439 int arg2 ;
22440 void *argp1 = 0 ;
22441 int res1 = 0 ;
22442 int val2 ;
22443 int ecode2 = 0 ;
22444 PyObject * obj0 = 0 ;
22445 PyObject * obj1 = 0 ;
22446 char * kwnames[] = {
22447 (char *) "self",(char *) "orient", NULL
22448 };
22449
22450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22454 }
22455 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22456 ecode2 = SWIG_AsVal_int(obj1, &val2);
22457 if (!SWIG_IsOK(ecode2)) {
22458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22459 }
22460 arg2 = static_cast< int >(val2);
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 (arg1)->SetOrientation(arg2);
22464 wxPyEndAllowThreads(__tstate);
22465 if (PyErr_Occurred()) SWIG_fail;
22466 }
22467 resultobj = SWIG_Py_Void();
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj = 0;
22476 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22477 int arg2 ;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 int val2 ;
22481 int ecode2 = 0 ;
22482 PyObject * obj0 = 0 ;
22483 PyObject * obj1 = 0 ;
22484 char * kwnames[] = {
22485 (char *) "self",(char *) "pos", NULL
22486 };
22487
22488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22492 }
22493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22494 ecode2 = SWIG_AsVal_int(obj1, &val2);
22495 if (!SWIG_IsOK(ecode2)) {
22496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22497 }
22498 arg2 = static_cast< int >(val2);
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 (arg1)->SetPosition(arg2);
22502 wxPyEndAllowThreads(__tstate);
22503 if (PyErr_Occurred()) SWIG_fail;
22504 }
22505 resultobj = SWIG_Py_Void();
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 PyObject *obj;
22514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22515 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22516 return SWIG_Py_Void();
22517 }
22518
22519 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520 return SWIG_Python_InitShadowInstance(args);
22521 }
22522
22523 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22526 int arg2 = (int) 0 ;
22527 int arg3 = (int) 0 ;
22528 wxScrollWinEvent *result = 0 ;
22529 int val1 ;
22530 int ecode1 = 0 ;
22531 int val2 ;
22532 int ecode2 = 0 ;
22533 int val3 ;
22534 int ecode3 = 0 ;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 PyObject * obj2 = 0 ;
22538 char * kwnames[] = {
22539 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22540 };
22541
22542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22543 if (obj0) {
22544 ecode1 = SWIG_AsVal_int(obj0, &val1);
22545 if (!SWIG_IsOK(ecode1)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22547 }
22548 arg1 = static_cast< wxEventType >(val1);
22549 }
22550 if (obj1) {
22551 ecode2 = SWIG_AsVal_int(obj1, &val2);
22552 if (!SWIG_IsOK(ecode2)) {
22553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22554 }
22555 arg2 = static_cast< int >(val2);
22556 }
22557 if (obj2) {
22558 ecode3 = SWIG_AsVal_int(obj2, &val3);
22559 if (!SWIG_IsOK(ecode3)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22561 }
22562 arg3 = static_cast< int >(val3);
22563 }
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22578 PyObject *resultobj = 0;
22579 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22580 int result;
22581 void *argp1 = 0 ;
22582 int res1 = 0 ;
22583 PyObject *swig_obj[1] ;
22584
22585 if (!args) SWIG_fail;
22586 swig_obj[0] = args;
22587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22590 }
22591 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22592 {
22593 PyThreadState* __tstate = wxPyBeginAllowThreads();
22594 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22595 wxPyEndAllowThreads(__tstate);
22596 if (PyErr_Occurred()) SWIG_fail;
22597 }
22598 resultobj = SWIG_From_int(static_cast< int >(result));
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22606 PyObject *resultobj = 0;
22607 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22608 int result;
22609 void *argp1 = 0 ;
22610 int res1 = 0 ;
22611 PyObject *swig_obj[1] ;
22612
22613 if (!args) SWIG_fail;
22614 swig_obj[0] = args;
22615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22616 if (!SWIG_IsOK(res1)) {
22617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22618 }
22619 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_From_int(static_cast< int >(result));
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj = 0;
22635 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22636 int arg2 ;
22637 void *argp1 = 0 ;
22638 int res1 = 0 ;
22639 int val2 ;
22640 int ecode2 = 0 ;
22641 PyObject * obj0 = 0 ;
22642 PyObject * obj1 = 0 ;
22643 char * kwnames[] = {
22644 (char *) "self",(char *) "orient", NULL
22645 };
22646
22647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22649 if (!SWIG_IsOK(res1)) {
22650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22651 }
22652 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22653 ecode2 = SWIG_AsVal_int(obj1, &val2);
22654 if (!SWIG_IsOK(ecode2)) {
22655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22656 }
22657 arg2 = static_cast< int >(val2);
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 (arg1)->SetOrientation(arg2);
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 resultobj = SWIG_Py_Void();
22665 return resultobj;
22666 fail:
22667 return NULL;
22668 }
22669
22670
22671 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22672 PyObject *resultobj = 0;
22673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22674 int arg2 ;
22675 void *argp1 = 0 ;
22676 int res1 = 0 ;
22677 int val2 ;
22678 int ecode2 = 0 ;
22679 PyObject * obj0 = 0 ;
22680 PyObject * obj1 = 0 ;
22681 char * kwnames[] = {
22682 (char *) "self",(char *) "pos", NULL
22683 };
22684
22685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22689 }
22690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22691 ecode2 = SWIG_AsVal_int(obj1, &val2);
22692 if (!SWIG_IsOK(ecode2)) {
22693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22694 }
22695 arg2 = static_cast< int >(val2);
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 (arg1)->SetPosition(arg2);
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 resultobj = SWIG_Py_Void();
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *obj;
22711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22712 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22713 return SWIG_Py_Void();
22714 }
22715
22716 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 return SWIG_Python_InitShadowInstance(args);
22718 }
22719
22720 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj = 0;
22722 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22723 wxMouseEvent *result = 0 ;
22724 int val1 ;
22725 int ecode1 = 0 ;
22726 PyObject * obj0 = 0 ;
22727 char * kwnames[] = {
22728 (char *) "mouseType", NULL
22729 };
22730
22731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22732 if (obj0) {
22733 ecode1 = SWIG_AsVal_int(obj0, &val1);
22734 if (!SWIG_IsOK(ecode1)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22736 }
22737 arg1 = static_cast< wxEventType >(val1);
22738 }
22739 {
22740 PyThreadState* __tstate = wxPyBeginAllowThreads();
22741 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22753 PyObject *resultobj = 0;
22754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22755 bool result;
22756 void *argp1 = 0 ;
22757 int res1 = 0 ;
22758 PyObject *swig_obj[1] ;
22759
22760 if (!args) SWIG_fail;
22761 swig_obj[0] = args;
22762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22763 if (!SWIG_IsOK(res1)) {
22764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22765 }
22766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22770 wxPyEndAllowThreads(__tstate);
22771 if (PyErr_Occurred()) SWIG_fail;
22772 }
22773 {
22774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22775 }
22776 return resultobj;
22777 fail:
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22783 PyObject *resultobj = 0;
22784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22785 int arg2 = (int) wxMOUSE_BTN_ANY ;
22786 bool result;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 int val2 ;
22790 int ecode2 = 0 ;
22791 PyObject * obj0 = 0 ;
22792 PyObject * obj1 = 0 ;
22793 char * kwnames[] = {
22794 (char *) "self",(char *) "but", NULL
22795 };
22796
22797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22801 }
22802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22803 if (obj1) {
22804 ecode2 = SWIG_AsVal_int(obj1, &val2);
22805 if (!SWIG_IsOK(ecode2)) {
22806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22807 }
22808 arg2 = static_cast< int >(val2);
22809 }
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22826 PyObject *resultobj = 0;
22827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22828 int arg2 = (int) wxMOUSE_BTN_ANY ;
22829 bool result;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 int val2 ;
22833 int ecode2 = 0 ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char * kwnames[] = {
22837 (char *) "self",(char *) "but", NULL
22838 };
22839
22840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22842 if (!SWIG_IsOK(res1)) {
22843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22844 }
22845 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22846 if (obj1) {
22847 ecode2 = SWIG_AsVal_int(obj1, &val2);
22848 if (!SWIG_IsOK(ecode2)) {
22849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22850 }
22851 arg2 = static_cast< int >(val2);
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22869 PyObject *resultobj = 0;
22870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22871 int arg2 = (int) wxMOUSE_BTN_ANY ;
22872 bool result;
22873 void *argp1 = 0 ;
22874 int res1 = 0 ;
22875 int val2 ;
22876 int ecode2 = 0 ;
22877 PyObject * obj0 = 0 ;
22878 PyObject * obj1 = 0 ;
22879 char * kwnames[] = {
22880 (char *) "self",(char *) "but", NULL
22881 };
22882
22883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22887 }
22888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22889 if (obj1) {
22890 ecode2 = SWIG_AsVal_int(obj1, &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22893 }
22894 arg2 = static_cast< int >(val2);
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 {
22903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj = 0;
22913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22914 int arg2 ;
22915 bool result;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char * kwnames[] = {
22923 (char *) "self",(char *) "button", NULL
22924 };
22925
22926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22928 if (!SWIG_IsOK(res1)) {
22929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22930 }
22931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22932 ecode2 = SWIG_AsVal_int(obj1, &val2);
22933 if (!SWIG_IsOK(ecode2)) {
22934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22935 }
22936 arg2 = static_cast< int >(val2);
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 {
22944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22945 }
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22953 PyObject *resultobj = 0;
22954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22955 int arg2 ;
22956 bool result;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 int val2 ;
22960 int ecode2 = 0 ;
22961 PyObject * obj0 = 0 ;
22962 PyObject * obj1 = 0 ;
22963 char * kwnames[] = {
22964 (char *) "self",(char *) "but", NULL
22965 };
22966
22967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22971 }
22972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22973 ecode2 = SWIG_AsVal_int(obj1, &val2);
22974 if (!SWIG_IsOK(ecode2)) {
22975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22976 }
22977 arg2 = static_cast< int >(val2);
22978 {
22979 PyThreadState* __tstate = wxPyBeginAllowThreads();
22980 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22994 PyObject *resultobj = 0;
22995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22996 int result;
22997 void *argp1 = 0 ;
22998 int res1 = 0 ;
22999 PyObject *swig_obj[1] ;
23000
23001 if (!args) SWIG_fail;
23002 swig_obj[0] = args;
23003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23006 }
23007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 resultobj = SWIG_From_int(static_cast< int >(result));
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23022 PyObject *resultobj = 0;
23023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23024 bool result;
23025 void *argp1 = 0 ;
23026 int res1 = 0 ;
23027 PyObject *swig_obj[1] ;
23028
23029 if (!args) SWIG_fail;
23030 swig_obj[0] = args;
23031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23034 }
23035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23036 {
23037 PyThreadState* __tstate = wxPyBeginAllowThreads();
23038 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23039 wxPyEndAllowThreads(__tstate);
23040 if (PyErr_Occurred()) SWIG_fail;
23041 }
23042 {
23043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23044 }
23045 return resultobj;
23046 fail:
23047 return NULL;
23048 }
23049
23050
23051 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23052 PyObject *resultobj = 0;
23053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23054 bool result;
23055 void *argp1 = 0 ;
23056 int res1 = 0 ;
23057 PyObject *swig_obj[1] ;
23058
23059 if (!args) SWIG_fail;
23060 swig_obj[0] = args;
23061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23062 if (!SWIG_IsOK(res1)) {
23063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23064 }
23065 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23069 wxPyEndAllowThreads(__tstate);
23070 if (PyErr_Occurred()) SWIG_fail;
23071 }
23072 {
23073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23084 bool result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23104 }
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23112 PyObject *resultobj = 0;
23113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23114 bool result;
23115 void *argp1 = 0 ;
23116 int res1 = 0 ;
23117 PyObject *swig_obj[1] ;
23118
23119 if (!args) SWIG_fail;
23120 swig_obj[0] = args;
23121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23122 if (!SWIG_IsOK(res1)) {
23123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23124 }
23125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23129 wxPyEndAllowThreads(__tstate);
23130 if (PyErr_Occurred()) SWIG_fail;
23131 }
23132 {
23133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23134 }
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 PyObject *resultobj = 0;
23143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23144 bool result;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 PyObject *swig_obj[1] ;
23148
23149 if (!args) SWIG_fail;
23150 swig_obj[0] = args;
23151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23154 }
23155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 {
23163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23164 }
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23174 bool result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23184 }
23185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 {
23193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23194 }
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23202 PyObject *resultobj = 0;
23203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23204 bool result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 PyObject *swig_obj[1] ;
23208
23209 if (!args) SWIG_fail;
23210 swig_obj[0] = args;
23211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23214 }
23215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 {
23223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23224 }
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 PyObject *resultobj = 0;
23233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23234 bool result;
23235 void *argp1 = 0 ;
23236 int res1 = 0 ;
23237 PyObject *swig_obj[1] ;
23238
23239 if (!args) SWIG_fail;
23240 swig_obj[0] = args;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23244 }
23245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 {
23253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23254 }
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23262 PyObject *resultobj = 0;
23263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23264 bool result;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 PyObject *swig_obj[1] ;
23268
23269 if (!args) SWIG_fail;
23270 swig_obj[0] = args;
23271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23274 }
23275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23276 {
23277 PyThreadState* __tstate = wxPyBeginAllowThreads();
23278 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23279 wxPyEndAllowThreads(__tstate);
23280 if (PyErr_Occurred()) SWIG_fail;
23281 }
23282 {
23283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23284 }
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23292 PyObject *resultobj = 0;
23293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23294 bool result;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 PyObject *swig_obj[1] ;
23298
23299 if (!args) SWIG_fail;
23300 swig_obj[0] = args;
23301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23302 if (!SWIG_IsOK(res1)) {
23303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23304 }
23305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 {
23313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23314 }
23315 return resultobj;
23316 fail:
23317 return NULL;
23318 }
23319
23320
23321 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 PyObject *resultobj = 0;
23323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23324 bool result;
23325 void *argp1 = 0 ;
23326 int res1 = 0 ;
23327 PyObject *swig_obj[1] ;
23328
23329 if (!args) SWIG_fail;
23330 swig_obj[0] = args;
23331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23332 if (!SWIG_IsOK(res1)) {
23333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23334 }
23335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 {
23343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23344 }
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23352 PyObject *resultobj = 0;
23353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23354 bool result;
23355 void *argp1 = 0 ;
23356 int res1 = 0 ;
23357 PyObject *swig_obj[1] ;
23358
23359 if (!args) SWIG_fail;
23360 swig_obj[0] = args;
23361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23362 if (!SWIG_IsOK(res1)) {
23363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23364 }
23365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23369 wxPyEndAllowThreads(__tstate);
23370 if (PyErr_Occurred()) SWIG_fail;
23371 }
23372 {
23373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23374 }
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23382 PyObject *resultobj = 0;
23383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23384 bool result;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 PyObject *swig_obj[1] ;
23388
23389 if (!args) SWIG_fail;
23390 swig_obj[0] = args;
23391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23392 if (!SWIG_IsOK(res1)) {
23393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23394 }
23395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23414 bool result;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 PyObject *swig_obj[1] ;
23418
23419 if (!args) SWIG_fail;
23420 swig_obj[0] = args;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23424 }
23425 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23444 bool result;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 result = (bool)(arg1)->LeftIsDown();
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 {
23463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23464 }
23465 return resultobj;
23466 fail:
23467 return NULL;
23468 }
23469
23470
23471 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23472 PyObject *resultobj = 0;
23473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23474 bool result;
23475 void *argp1 = 0 ;
23476 int res1 = 0 ;
23477 PyObject *swig_obj[1] ;
23478
23479 if (!args) SWIG_fail;
23480 swig_obj[0] = args;
23481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23484 }
23485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (bool)(arg1)->MiddleIsDown();
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 {
23493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 PyObject *resultobj = 0;
23503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23504 bool result;
23505 void *argp1 = 0 ;
23506 int res1 = 0 ;
23507 PyObject *swig_obj[1] ;
23508
23509 if (!args) SWIG_fail;
23510 swig_obj[0] = args;
23511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23512 if (!SWIG_IsOK(res1)) {
23513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23514 }
23515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (bool)(arg1)->RightIsDown();
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 {
23523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23524 }
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23532 PyObject *resultobj = 0;
23533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23534 bool result;
23535 void *argp1 = 0 ;
23536 int res1 = 0 ;
23537 PyObject *swig_obj[1] ;
23538
23539 if (!args) SWIG_fail;
23540 swig_obj[0] = args;
23541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23542 if (!SWIG_IsOK(res1)) {
23543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23544 }
23545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23554 }
23555 return resultobj;
23556 fail:
23557 return NULL;
23558 }
23559
23560
23561 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23562 PyObject *resultobj = 0;
23563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23564 bool result;
23565 void *argp1 = 0 ;
23566 int res1 = 0 ;
23567 PyObject *swig_obj[1] ;
23568
23569 if (!args) SWIG_fail;
23570 swig_obj[0] = args;
23571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23572 if (!SWIG_IsOK(res1)) {
23573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23574 }
23575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 {
23583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23594 bool result;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 PyObject *swig_obj[1] ;
23598
23599 if (!args) SWIG_fail;
23600 swig_obj[0] = args;
23601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *resultobj = 0;
23623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23624 bool result;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 PyObject *swig_obj[1] ;
23628
23629 if (!args) SWIG_fail;
23630 swig_obj[0] = args;
23631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23632 if (!SWIG_IsOK(res1)) {
23633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23634 }
23635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23636 {
23637 PyThreadState* __tstate = wxPyBeginAllowThreads();
23638 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23652 PyObject *resultobj = 0;
23653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23654 wxPoint result;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 PyObject *swig_obj[1] ;
23658
23659 if (!args) SWIG_fail;
23660 swig_obj[0] = args;
23661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23662 if (!SWIG_IsOK(res1)) {
23663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23664 }
23665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23666 {
23667 PyThreadState* __tstate = wxPyBeginAllowThreads();
23668 result = (arg1)->GetPosition();
23669 wxPyEndAllowThreads(__tstate);
23670 if (PyErr_Occurred()) SWIG_fail;
23671 }
23672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23680 PyObject *resultobj = 0;
23681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23682 long *arg2 = (long *) 0 ;
23683 long *arg3 = (long *) 0 ;
23684 void *argp1 = 0 ;
23685 int res1 = 0 ;
23686 long temp2 ;
23687 int res2 = SWIG_TMPOBJ ;
23688 long temp3 ;
23689 int res3 = SWIG_TMPOBJ ;
23690 PyObject *swig_obj[1] ;
23691
23692 arg2 = &temp2;
23693 arg3 = &temp3;
23694 if (!args) SWIG_fail;
23695 swig_obj[0] = args;
23696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23699 }
23700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 (arg1)->GetPosition(arg2,arg3);
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 resultobj = SWIG_Py_Void();
23708 if (SWIG_IsTmpObj(res2)) {
23709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23710 } else {
23711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23713 }
23714 if (SWIG_IsTmpObj(res3)) {
23715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23716 } else {
23717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23719 }
23720 return resultobj;
23721 fail:
23722 return NULL;
23723 }
23724
23725
23726 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj = 0;
23728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23729 wxDC *arg2 = 0 ;
23730 wxPoint result;
23731 void *argp1 = 0 ;
23732 int res1 = 0 ;
23733 void *argp2 = 0 ;
23734 int res2 = 0 ;
23735 PyObject * obj0 = 0 ;
23736 PyObject * obj1 = 0 ;
23737 char * kwnames[] = {
23738 (char *) "self",(char *) "dc", NULL
23739 };
23740
23741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23745 }
23746 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23748 if (!SWIG_IsOK(res2)) {
23749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23750 }
23751 if (!argp2) {
23752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23753 }
23754 arg2 = reinterpret_cast< wxDC * >(argp2);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23769 PyObject *resultobj = 0;
23770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23771 int result;
23772 void *argp1 = 0 ;
23773 int res1 = 0 ;
23774 PyObject *swig_obj[1] ;
23775
23776 if (!args) SWIG_fail;
23777 swig_obj[0] = args;
23778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23779 if (!SWIG_IsOK(res1)) {
23780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23781 }
23782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (int)((wxMouseEvent const *)arg1)->GetX();
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_From_int(static_cast< int >(result));
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *resultobj = 0;
23798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23799 int result;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 PyObject *swig_obj[1] ;
23803
23804 if (!args) SWIG_fail;
23805 swig_obj[0] = args;
23806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23809 }
23810 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (int)((wxMouseEvent const *)arg1)->GetY();
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 resultobj = SWIG_From_int(static_cast< int >(result));
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 PyObject *resultobj = 0;
23826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23827 int result;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 PyObject *swig_obj[1] ;
23831
23832 if (!args) SWIG_fail;
23833 swig_obj[0] = args;
23834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23837 }
23838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_From_int(static_cast< int >(result));
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23855 int result;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 resultobj = SWIG_From_int(static_cast< int >(result));
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23881 PyObject *resultobj = 0;
23882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23883 int result;
23884 void *argp1 = 0 ;
23885 int res1 = 0 ;
23886 PyObject *swig_obj[1] ;
23887
23888 if (!args) SWIG_fail;
23889 swig_obj[0] = args;
23890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23891 if (!SWIG_IsOK(res1)) {
23892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23893 }
23894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23898 wxPyEndAllowThreads(__tstate);
23899 if (PyErr_Occurred()) SWIG_fail;
23900 }
23901 resultobj = SWIG_From_int(static_cast< int >(result));
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23909 PyObject *resultobj = 0;
23910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23911 bool result;
23912 void *argp1 = 0 ;
23913 int res1 = 0 ;
23914 PyObject *swig_obj[1] ;
23915
23916 if (!args) SWIG_fail;
23917 swig_obj[0] = args;
23918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23919 if (!SWIG_IsOK(res1)) {
23920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23921 }
23922 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23931 }
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *resultobj = 0;
23940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23941 int arg2 ;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 int val2 ;
23945 int ecode2 = 0 ;
23946 PyObject *swig_obj[2] ;
23947
23948 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23950 if (!SWIG_IsOK(res1)) {
23951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23952 }
23953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23954 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23955 if (!SWIG_IsOK(ecode2)) {
23956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23957 }
23958 arg2 = static_cast< int >(val2);
23959 if (arg1) (arg1)->m_x = arg2;
23960
23961 resultobj = SWIG_Py_Void();
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 PyObject *resultobj = 0;
23970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23971 int result;
23972 void *argp1 = 0 ;
23973 int res1 = 0 ;
23974 PyObject *swig_obj[1] ;
23975
23976 if (!args) SWIG_fail;
23977 swig_obj[0] = args;
23978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23979 if (!SWIG_IsOK(res1)) {
23980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23981 }
23982 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23983 result = (int) ((arg1)->m_x);
23984 resultobj = SWIG_From_int(static_cast< int >(result));
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23994 int arg2 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 int val2 ;
23998 int ecode2 = 0 ;
23999 PyObject *swig_obj[2] ;
24000
24001 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24005 }
24006 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24007 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24008 if (!SWIG_IsOK(ecode2)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24010 }
24011 arg2 = static_cast< int >(val2);
24012 if (arg1) (arg1)->m_y = arg2;
24013
24014 resultobj = SWIG_Py_Void();
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24024 int result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24036 result = (int) ((arg1)->m_y);
24037 resultobj = SWIG_From_int(static_cast< int >(result));
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24045 PyObject *resultobj = 0;
24046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24047 bool arg2 ;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 bool val2 ;
24051 int ecode2 = 0 ;
24052 PyObject *swig_obj[2] ;
24053
24054 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24056 if (!SWIG_IsOK(res1)) {
24057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24058 }
24059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24060 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24061 if (!SWIG_IsOK(ecode2)) {
24062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24063 }
24064 arg2 = static_cast< bool >(val2);
24065 if (arg1) (arg1)->m_leftDown = arg2;
24066
24067 resultobj = SWIG_Py_Void();
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24075 PyObject *resultobj = 0;
24076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24077 bool result;
24078 void *argp1 = 0 ;
24079 int res1 = 0 ;
24080 PyObject *swig_obj[1] ;
24081
24082 if (!args) SWIG_fail;
24083 swig_obj[0] = args;
24084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24087 }
24088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24089 result = (bool) ((arg1)->m_leftDown);
24090 {
24091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24092 }
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 PyObject *resultobj = 0;
24101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24102 bool arg2 ;
24103 void *argp1 = 0 ;
24104 int res1 = 0 ;
24105 bool val2 ;
24106 int ecode2 = 0 ;
24107 PyObject *swig_obj[2] ;
24108
24109 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24113 }
24114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24115 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24116 if (!SWIG_IsOK(ecode2)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24118 }
24119 arg2 = static_cast< bool >(val2);
24120 if (arg1) (arg1)->m_middleDown = arg2;
24121
24122 resultobj = SWIG_Py_Void();
24123 return resultobj;
24124 fail:
24125 return NULL;
24126 }
24127
24128
24129 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24130 PyObject *resultobj = 0;
24131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24132 bool result;
24133 void *argp1 = 0 ;
24134 int res1 = 0 ;
24135 PyObject *swig_obj[1] ;
24136
24137 if (!args) SWIG_fail;
24138 swig_obj[0] = args;
24139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24140 if (!SWIG_IsOK(res1)) {
24141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24142 }
24143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24144 result = (bool) ((arg1)->m_middleDown);
24145 {
24146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24155 PyObject *resultobj = 0;
24156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24157 bool arg2 ;
24158 void *argp1 = 0 ;
24159 int res1 = 0 ;
24160 bool val2 ;
24161 int ecode2 = 0 ;
24162 PyObject *swig_obj[2] ;
24163
24164 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24168 }
24169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24170 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24171 if (!SWIG_IsOK(ecode2)) {
24172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24173 }
24174 arg2 = static_cast< bool >(val2);
24175 if (arg1) (arg1)->m_rightDown = arg2;
24176
24177 resultobj = SWIG_Py_Void();
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24187 bool result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24197 }
24198 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24199 result = (bool) ((arg1)->m_rightDown);
24200 {
24201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24202 }
24203 return resultobj;
24204 fail:
24205 return NULL;
24206 }
24207
24208
24209 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24210 PyObject *resultobj = 0;
24211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24212 bool arg2 ;
24213 void *argp1 = 0 ;
24214 int res1 = 0 ;
24215 bool val2 ;
24216 int ecode2 = 0 ;
24217 PyObject *swig_obj[2] ;
24218
24219 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24221 if (!SWIG_IsOK(res1)) {
24222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24223 }
24224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24225 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24226 if (!SWIG_IsOK(ecode2)) {
24227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24228 }
24229 arg2 = static_cast< bool >(val2);
24230 if (arg1) (arg1)->m_controlDown = arg2;
24231
24232 resultobj = SWIG_Py_Void();
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24240 PyObject *resultobj = 0;
24241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24242 bool result;
24243 void *argp1 = 0 ;
24244 int res1 = 0 ;
24245 PyObject *swig_obj[1] ;
24246
24247 if (!args) SWIG_fail;
24248 swig_obj[0] = args;
24249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24250 if (!SWIG_IsOK(res1)) {
24251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24252 }
24253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24254 result = (bool) ((arg1)->m_controlDown);
24255 {
24256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24257 }
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24267 bool arg2 ;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 bool val2 ;
24271 int ecode2 = 0 ;
24272 PyObject *swig_obj[2] ;
24273
24274 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24278 }
24279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24280 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24281 if (!SWIG_IsOK(ecode2)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24283 }
24284 arg2 = static_cast< bool >(val2);
24285 if (arg1) (arg1)->m_shiftDown = arg2;
24286
24287 resultobj = SWIG_Py_Void();
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24297 bool result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24309 result = (bool) ((arg1)->m_shiftDown);
24310 {
24311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24312 }
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24322 bool arg2 ;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 bool val2 ;
24326 int ecode2 = 0 ;
24327 PyObject *swig_obj[2] ;
24328
24329 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24331 if (!SWIG_IsOK(res1)) {
24332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24333 }
24334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24335 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24336 if (!SWIG_IsOK(ecode2)) {
24337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24338 }
24339 arg2 = static_cast< bool >(val2);
24340 if (arg1) (arg1)->m_altDown = arg2;
24341
24342 resultobj = SWIG_Py_Void();
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24350 PyObject *resultobj = 0;
24351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24352 bool result;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 PyObject *swig_obj[1] ;
24356
24357 if (!args) SWIG_fail;
24358 swig_obj[0] = args;
24359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24360 if (!SWIG_IsOK(res1)) {
24361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24362 }
24363 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24364 result = (bool) ((arg1)->m_altDown);
24365 {
24366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24367 }
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24375 PyObject *resultobj = 0;
24376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24377 bool arg2 ;
24378 void *argp1 = 0 ;
24379 int res1 = 0 ;
24380 bool val2 ;
24381 int ecode2 = 0 ;
24382 PyObject *swig_obj[2] ;
24383
24384 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24388 }
24389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24390 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24391 if (!SWIG_IsOK(ecode2)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24393 }
24394 arg2 = static_cast< bool >(val2);
24395 if (arg1) (arg1)->m_metaDown = arg2;
24396
24397 resultobj = SWIG_Py_Void();
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24407 bool result;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 PyObject *swig_obj[1] ;
24411
24412 if (!args) SWIG_fail;
24413 swig_obj[0] = args;
24414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24415 if (!SWIG_IsOK(res1)) {
24416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24417 }
24418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24419 result = (bool) ((arg1)->m_metaDown);
24420 {
24421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24430 PyObject *resultobj = 0;
24431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24432 int arg2 ;
24433 void *argp1 = 0 ;
24434 int res1 = 0 ;
24435 int val2 ;
24436 int ecode2 = 0 ;
24437 PyObject *swig_obj[2] ;
24438
24439 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24443 }
24444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24445 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24446 if (!SWIG_IsOK(ecode2)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24448 }
24449 arg2 = static_cast< int >(val2);
24450 if (arg1) (arg1)->m_wheelRotation = arg2;
24451
24452 resultobj = SWIG_Py_Void();
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24460 PyObject *resultobj = 0;
24461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24462 int result;
24463 void *argp1 = 0 ;
24464 int res1 = 0 ;
24465 PyObject *swig_obj[1] ;
24466
24467 if (!args) SWIG_fail;
24468 swig_obj[0] = args;
24469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24470 if (!SWIG_IsOK(res1)) {
24471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24472 }
24473 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24474 result = (int) ((arg1)->m_wheelRotation);
24475 resultobj = SWIG_From_int(static_cast< int >(result));
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24483 PyObject *resultobj = 0;
24484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24485 int arg2 ;
24486 void *argp1 = 0 ;
24487 int res1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 PyObject *swig_obj[2] ;
24491
24492 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24494 if (!SWIG_IsOK(res1)) {
24495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24496 }
24497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24498 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24499 if (!SWIG_IsOK(ecode2)) {
24500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24501 }
24502 arg2 = static_cast< int >(val2);
24503 if (arg1) (arg1)->m_wheelDelta = arg2;
24504
24505 resultobj = SWIG_Py_Void();
24506 return resultobj;
24507 fail:
24508 return NULL;
24509 }
24510
24511
24512 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24513 PyObject *resultobj = 0;
24514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24515 int result;
24516 void *argp1 = 0 ;
24517 int res1 = 0 ;
24518 PyObject *swig_obj[1] ;
24519
24520 if (!args) SWIG_fail;
24521 swig_obj[0] = args;
24522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24523 if (!SWIG_IsOK(res1)) {
24524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24525 }
24526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24527 result = (int) ((arg1)->m_wheelDelta);
24528 resultobj = SWIG_From_int(static_cast< int >(result));
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 PyObject *resultobj = 0;
24537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24538 int arg2 ;
24539 void *argp1 = 0 ;
24540 int res1 = 0 ;
24541 int val2 ;
24542 int ecode2 = 0 ;
24543 PyObject *swig_obj[2] ;
24544
24545 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24547 if (!SWIG_IsOK(res1)) {
24548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24549 }
24550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24552 if (!SWIG_IsOK(ecode2)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24554 }
24555 arg2 = static_cast< int >(val2);
24556 if (arg1) (arg1)->m_linesPerAction = arg2;
24557
24558 resultobj = SWIG_Py_Void();
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24566 PyObject *resultobj = 0;
24567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24568 int result;
24569 void *argp1 = 0 ;
24570 int res1 = 0 ;
24571 PyObject *swig_obj[1] ;
24572
24573 if (!args) SWIG_fail;
24574 swig_obj[0] = args;
24575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24576 if (!SWIG_IsOK(res1)) {
24577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24578 }
24579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24580 result = (int) ((arg1)->m_linesPerAction);
24581 resultobj = SWIG_From_int(static_cast< int >(result));
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24589 PyObject *obj;
24590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24591 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24592 return SWIG_Py_Void();
24593 }
24594
24595 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 return SWIG_Python_InitShadowInstance(args);
24597 }
24598
24599 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj = 0;
24601 int arg1 = (int) 0 ;
24602 int arg2 = (int) 0 ;
24603 wxSetCursorEvent *result = 0 ;
24604 int val1 ;
24605 int ecode1 = 0 ;
24606 int val2 ;
24607 int ecode2 = 0 ;
24608 PyObject * obj0 = 0 ;
24609 PyObject * obj1 = 0 ;
24610 char * kwnames[] = {
24611 (char *) "x",(char *) "y", NULL
24612 };
24613
24614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24615 if (obj0) {
24616 ecode1 = SWIG_AsVal_int(obj0, &val1);
24617 if (!SWIG_IsOK(ecode1)) {
24618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24619 }
24620 arg1 = static_cast< int >(val1);
24621 }
24622 if (obj1) {
24623 ecode2 = SWIG_AsVal_int(obj1, &val2);
24624 if (!SWIG_IsOK(ecode2)) {
24625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24626 }
24627 arg2 = static_cast< int >(val2);
24628 }
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24636 return resultobj;
24637 fail:
24638 return NULL;
24639 }
24640
24641
24642 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24643 PyObject *resultobj = 0;
24644 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24645 int result;
24646 void *argp1 = 0 ;
24647 int res1 = 0 ;
24648 PyObject *swig_obj[1] ;
24649
24650 if (!args) SWIG_fail;
24651 swig_obj[0] = args;
24652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24653 if (!SWIG_IsOK(res1)) {
24654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24655 }
24656 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24657 {
24658 PyThreadState* __tstate = wxPyBeginAllowThreads();
24659 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24660 wxPyEndAllowThreads(__tstate);
24661 if (PyErr_Occurred()) SWIG_fail;
24662 }
24663 resultobj = SWIG_From_int(static_cast< int >(result));
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24671 PyObject *resultobj = 0;
24672 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24673 int result;
24674 void *argp1 = 0 ;
24675 int res1 = 0 ;
24676 PyObject *swig_obj[1] ;
24677
24678 if (!args) SWIG_fail;
24679 swig_obj[0] = args;
24680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24681 if (!SWIG_IsOK(res1)) {
24682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24683 }
24684 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24685 {
24686 PyThreadState* __tstate = wxPyBeginAllowThreads();
24687 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24688 wxPyEndAllowThreads(__tstate);
24689 if (PyErr_Occurred()) SWIG_fail;
24690 }
24691 resultobj = SWIG_From_int(static_cast< int >(result));
24692 return resultobj;
24693 fail:
24694 return NULL;
24695 }
24696
24697
24698 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = 0;
24700 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24701 wxCursor *arg2 = 0 ;
24702 void *argp1 = 0 ;
24703 int res1 = 0 ;
24704 void *argp2 = 0 ;
24705 int res2 = 0 ;
24706 PyObject * obj0 = 0 ;
24707 PyObject * obj1 = 0 ;
24708 char * kwnames[] = {
24709 (char *) "self",(char *) "cursor", NULL
24710 };
24711
24712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24714 if (!SWIG_IsOK(res1)) {
24715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24716 }
24717 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24719 if (!SWIG_IsOK(res2)) {
24720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24721 }
24722 if (!argp2) {
24723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24724 }
24725 arg2 = reinterpret_cast< wxCursor * >(argp2);
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 (arg1)->SetCursor((wxCursor const &)*arg2);
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_Py_Void();
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24742 wxCursor *result = 0 ;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 PyObject *swig_obj[1] ;
24746
24747 if (!args) SWIG_fail;
24748 swig_obj[0] = args;
24749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24752 }
24753 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 {
24757 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24758 result = (wxCursor *) &_result_ref;
24759 }
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 {
24764 wxCursor* resultptr = new wxCursor(*result);
24765 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24766 }
24767 return resultobj;
24768 fail:
24769 return NULL;
24770 }
24771
24772
24773 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24774 PyObject *resultobj = 0;
24775 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24776 bool result;
24777 void *argp1 = 0 ;
24778 int res1 = 0 ;
24779 PyObject *swig_obj[1] ;
24780
24781 if (!args) SWIG_fail;
24782 swig_obj[0] = args;
24783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24784 if (!SWIG_IsOK(res1)) {
24785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24786 }
24787 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24788 {
24789 PyThreadState* __tstate = wxPyBeginAllowThreads();
24790 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *obj;
24805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24806 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24807 return SWIG_Py_Void();
24808 }
24809
24810 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 return SWIG_Python_InitShadowInstance(args);
24812 }
24813
24814 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24817 wxKeyEvent *result = 0 ;
24818 int val1 ;
24819 int ecode1 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "eventType", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24826 if (obj0) {
24827 ecode1 = SWIG_AsVal_int(obj0, &val1);
24828 if (!SWIG_IsOK(ecode1)) {
24829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24830 }
24831 arg1 = static_cast< wxEventType >(val1);
24832 }
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24849 int result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 resultobj = SWIG_From_int(static_cast< int >(result));
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24875 PyObject *resultobj = 0;
24876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24877 bool result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 PyObject *swig_obj[1] ;
24881
24882 if (!args) SWIG_fail;
24883 swig_obj[0] = args;
24884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24887 }
24888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24897 }
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24905 PyObject *resultobj = 0;
24906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24907 bool result;
24908 void *argp1 = 0 ;
24909 int res1 = 0 ;
24910 PyObject *swig_obj[1] ;
24911
24912 if (!args) SWIG_fail;
24913 swig_obj[0] = args;
24914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24915 if (!SWIG_IsOK(res1)) {
24916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24917 }
24918 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 {
24926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24927 }
24928 return resultobj;
24929 fail:
24930 return NULL;
24931 }
24932
24933
24934 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24935 PyObject *resultobj = 0;
24936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24937 bool result;
24938 void *argp1 = 0 ;
24939 int res1 = 0 ;
24940 PyObject *swig_obj[1] ;
24941
24942 if (!args) SWIG_fail;
24943 swig_obj[0] = args;
24944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24947 }
24948 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 {
24956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24957 }
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24965 PyObject *resultobj = 0;
24966 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24967 bool result;
24968 void *argp1 = 0 ;
24969 int res1 = 0 ;
24970 PyObject *swig_obj[1] ;
24971
24972 if (!args) SWIG_fail;
24973 swig_obj[0] = args;
24974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24975 if (!SWIG_IsOK(res1)) {
24976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24977 }
24978 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24979 {
24980 PyThreadState* __tstate = wxPyBeginAllowThreads();
24981 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24982 wxPyEndAllowThreads(__tstate);
24983 if (PyErr_Occurred()) SWIG_fail;
24984 }
24985 {
24986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24987 }
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24995 PyObject *resultobj = 0;
24996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24997 bool result;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 PyObject *swig_obj[1] ;
25001
25002 if (!args) SWIG_fail;
25003 swig_obj[0] = args;
25004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25005 if (!SWIG_IsOK(res1)) {
25006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25007 }
25008 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 {
25016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25017 }
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25025 PyObject *resultobj = 0;
25026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25027 bool result;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 PyObject *swig_obj[1] ;
25031
25032 if (!args) SWIG_fail;
25033 swig_obj[0] = args;
25034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25037 }
25038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 {
25046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25055 PyObject *resultobj = 0;
25056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25057 int result;
25058 void *argp1 = 0 ;
25059 int res1 = 0 ;
25060 PyObject *swig_obj[1] ;
25061
25062 if (!args) SWIG_fail;
25063 swig_obj[0] = args;
25064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25065 if (!SWIG_IsOK(res1)) {
25066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25067 }
25068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_From_int(static_cast< int >(result));
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25083 PyObject *resultobj = 0;
25084 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25085 int result;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 PyObject *swig_obj[1] ;
25089
25090 if (!args) SWIG_fail;
25091 swig_obj[0] = args;
25092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25095 }
25096 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 resultobj = SWIG_From_int(static_cast< int >(result));
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj = 0;
25112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25113 int arg2 ;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 int val2 ;
25117 int ecode2 = 0 ;
25118 PyObject * obj0 = 0 ;
25119 PyObject * obj1 = 0 ;
25120 char * kwnames[] = {
25121 (char *) "self",(char *) "uniChar", NULL
25122 };
25123
25124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25126 if (!SWIG_IsOK(res1)) {
25127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25128 }
25129 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25130 ecode2 = SWIG_AsVal_int(obj1, &val2);
25131 if (!SWIG_IsOK(ecode2)) {
25132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25133 }
25134 arg2 = static_cast< int >(val2);
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 resultobj = SWIG_Py_Void();
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25151 unsigned int result;
25152 void *argp1 = 0 ;
25153 int res1 = 0 ;
25154 PyObject *swig_obj[1] ;
25155
25156 if (!args) SWIG_fail;
25157 swig_obj[0] = args;
25158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25159 if (!SWIG_IsOK(res1)) {
25160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25161 }
25162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25177 PyObject *resultobj = 0;
25178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25179 unsigned int result;
25180 void *argp1 = 0 ;
25181 int res1 = 0 ;
25182 PyObject *swig_obj[1] ;
25183
25184 if (!args) SWIG_fail;
25185 swig_obj[0] = args;
25186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25187 if (!SWIG_IsOK(res1)) {
25188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25189 }
25190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25191 {
25192 PyThreadState* __tstate = wxPyBeginAllowThreads();
25193 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25194 wxPyEndAllowThreads(__tstate);
25195 if (PyErr_Occurred()) SWIG_fail;
25196 }
25197 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25198 return resultobj;
25199 fail:
25200 return NULL;
25201 }
25202
25203
25204 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25205 PyObject *resultobj = 0;
25206 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25207 wxPoint result;
25208 void *argp1 = 0 ;
25209 int res1 = 0 ;
25210 PyObject *swig_obj[1] ;
25211
25212 if (!args) SWIG_fail;
25213 swig_obj[0] = args;
25214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25217 }
25218 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (arg1)->GetPosition();
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25233 PyObject *resultobj = 0;
25234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25235 long *arg2 = (long *) 0 ;
25236 long *arg3 = (long *) 0 ;
25237 void *argp1 = 0 ;
25238 int res1 = 0 ;
25239 long temp2 ;
25240 int res2 = SWIG_TMPOBJ ;
25241 long temp3 ;
25242 int res3 = SWIG_TMPOBJ ;
25243 PyObject *swig_obj[1] ;
25244
25245 arg2 = &temp2;
25246 arg3 = &temp3;
25247 if (!args) SWIG_fail;
25248 swig_obj[0] = args;
25249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25250 if (!SWIG_IsOK(res1)) {
25251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25252 }
25253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 (arg1)->GetPosition(arg2,arg3);
25257 wxPyEndAllowThreads(__tstate);
25258 if (PyErr_Occurred()) SWIG_fail;
25259 }
25260 resultobj = SWIG_Py_Void();
25261 if (SWIG_IsTmpObj(res2)) {
25262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25263 } else {
25264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25266 }
25267 if (SWIG_IsTmpObj(res3)) {
25268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25269 } else {
25270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25272 }
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25280 PyObject *resultobj = 0;
25281 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25282 int result;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 PyObject *swig_obj[1] ;
25286
25287 if (!args) SWIG_fail;
25288 swig_obj[0] = args;
25289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25290 if (!SWIG_IsOK(res1)) {
25291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25292 }
25293 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = (int)((wxKeyEvent const *)arg1)->GetX();
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 resultobj = SWIG_From_int(static_cast< int >(result));
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25308 PyObject *resultobj = 0;
25309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25310 int result;
25311 void *argp1 = 0 ;
25312 int res1 = 0 ;
25313 PyObject *swig_obj[1] ;
25314
25315 if (!args) SWIG_fail;
25316 swig_obj[0] = args;
25317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25318 if (!SWIG_IsOK(res1)) {
25319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25320 }
25321 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (int)((wxKeyEvent const *)arg1)->GetY();
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 resultobj = SWIG_From_int(static_cast< int >(result));
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *resultobj = 0;
25337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25338 int arg2 ;
25339 void *argp1 = 0 ;
25340 int res1 = 0 ;
25341 int val2 ;
25342 int ecode2 = 0 ;
25343 PyObject *swig_obj[2] ;
25344
25345 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25349 }
25350 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25351 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25352 if (!SWIG_IsOK(ecode2)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25354 }
25355 arg2 = static_cast< int >(val2);
25356 if (arg1) (arg1)->m_x = arg2;
25357
25358 resultobj = SWIG_Py_Void();
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25366 PyObject *resultobj = 0;
25367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25368 int result;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 PyObject *swig_obj[1] ;
25372
25373 if (!args) SWIG_fail;
25374 swig_obj[0] = args;
25375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25376 if (!SWIG_IsOK(res1)) {
25377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25378 }
25379 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25380 result = (int) ((arg1)->m_x);
25381 resultobj = SWIG_From_int(static_cast< int >(result));
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25389 PyObject *resultobj = 0;
25390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25391 int arg2 ;
25392 void *argp1 = 0 ;
25393 int res1 = 0 ;
25394 int val2 ;
25395 int ecode2 = 0 ;
25396 PyObject *swig_obj[2] ;
25397
25398 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25400 if (!SWIG_IsOK(res1)) {
25401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25402 }
25403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25404 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25405 if (!SWIG_IsOK(ecode2)) {
25406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25407 }
25408 arg2 = static_cast< int >(val2);
25409 if (arg1) (arg1)->m_y = arg2;
25410
25411 resultobj = SWIG_Py_Void();
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25421 int result;
25422 void *argp1 = 0 ;
25423 int res1 = 0 ;
25424 PyObject *swig_obj[1] ;
25425
25426 if (!args) SWIG_fail;
25427 swig_obj[0] = args;
25428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25429 if (!SWIG_IsOK(res1)) {
25430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25431 }
25432 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25433 result = (int) ((arg1)->m_y);
25434 resultobj = SWIG_From_int(static_cast< int >(result));
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25442 PyObject *resultobj = 0;
25443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25444 long arg2 ;
25445 void *argp1 = 0 ;
25446 int res1 = 0 ;
25447 long val2 ;
25448 int ecode2 = 0 ;
25449 PyObject *swig_obj[2] ;
25450
25451 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25453 if (!SWIG_IsOK(res1)) {
25454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25455 }
25456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25457 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25458 if (!SWIG_IsOK(ecode2)) {
25459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25460 }
25461 arg2 = static_cast< long >(val2);
25462 if (arg1) (arg1)->m_keyCode = arg2;
25463
25464 resultobj = SWIG_Py_Void();
25465 return resultobj;
25466 fail:
25467 return NULL;
25468 }
25469
25470
25471 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 PyObject *resultobj = 0;
25473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25474 long result;
25475 void *argp1 = 0 ;
25476 int res1 = 0 ;
25477 PyObject *swig_obj[1] ;
25478
25479 if (!args) SWIG_fail;
25480 swig_obj[0] = args;
25481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25482 if (!SWIG_IsOK(res1)) {
25483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25484 }
25485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25486 result = (long) ((arg1)->m_keyCode);
25487 resultobj = SWIG_From_long(static_cast< long >(result));
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25497 bool arg2 ;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 bool val2 ;
25501 int ecode2 = 0 ;
25502 PyObject *swig_obj[2] ;
25503
25504 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25506 if (!SWIG_IsOK(res1)) {
25507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25508 }
25509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25510 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25511 if (!SWIG_IsOK(ecode2)) {
25512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25513 }
25514 arg2 = static_cast< bool >(val2);
25515 if (arg1) (arg1)->m_controlDown = arg2;
25516
25517 resultobj = SWIG_Py_Void();
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 PyObject *resultobj = 0;
25526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25527 bool result;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 PyObject *swig_obj[1] ;
25531
25532 if (!args) SWIG_fail;
25533 swig_obj[0] = args;
25534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25535 if (!SWIG_IsOK(res1)) {
25536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25537 }
25538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25539 result = (bool) ((arg1)->m_controlDown);
25540 {
25541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25542 }
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25550 PyObject *resultobj = 0;
25551 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25552 bool arg2 ;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 bool val2 ;
25556 int ecode2 = 0 ;
25557 PyObject *swig_obj[2] ;
25558
25559 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25563 }
25564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25565 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25566 if (!SWIG_IsOK(ecode2)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25568 }
25569 arg2 = static_cast< bool >(val2);
25570 if (arg1) (arg1)->m_shiftDown = arg2;
25571
25572 resultobj = SWIG_Py_Void();
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 PyObject *resultobj = 0;
25581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25582 bool result;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 PyObject *swig_obj[1] ;
25586
25587 if (!args) SWIG_fail;
25588 swig_obj[0] = args;
25589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25592 }
25593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25594 result = (bool) ((arg1)->m_shiftDown);
25595 {
25596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25605 PyObject *resultobj = 0;
25606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25607 bool arg2 ;
25608 void *argp1 = 0 ;
25609 int res1 = 0 ;
25610 bool val2 ;
25611 int ecode2 = 0 ;
25612 PyObject *swig_obj[2] ;
25613
25614 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25618 }
25619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25620 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25621 if (!SWIG_IsOK(ecode2)) {
25622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25623 }
25624 arg2 = static_cast< bool >(val2);
25625 if (arg1) (arg1)->m_altDown = arg2;
25626
25627 resultobj = SWIG_Py_Void();
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25635 PyObject *resultobj = 0;
25636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25637 bool result;
25638 void *argp1 = 0 ;
25639 int res1 = 0 ;
25640 PyObject *swig_obj[1] ;
25641
25642 if (!args) SWIG_fail;
25643 swig_obj[0] = args;
25644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25645 if (!SWIG_IsOK(res1)) {
25646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25647 }
25648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25649 result = (bool) ((arg1)->m_altDown);
25650 {
25651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25652 }
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25662 bool arg2 ;
25663 void *argp1 = 0 ;
25664 int res1 = 0 ;
25665 bool val2 ;
25666 int ecode2 = 0 ;
25667 PyObject *swig_obj[2] ;
25668
25669 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25671 if (!SWIG_IsOK(res1)) {
25672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25673 }
25674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25675 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25676 if (!SWIG_IsOK(ecode2)) {
25677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25678 }
25679 arg2 = static_cast< bool >(val2);
25680 if (arg1) (arg1)->m_metaDown = arg2;
25681
25682 resultobj = SWIG_Py_Void();
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25690 PyObject *resultobj = 0;
25691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25692 bool result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 PyObject *swig_obj[1] ;
25696
25697 if (!args) SWIG_fail;
25698 swig_obj[0] = args;
25699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25702 }
25703 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25704 result = (bool) ((arg1)->m_metaDown);
25705 {
25706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25707 }
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *resultobj = 0;
25716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25717 bool arg2 ;
25718 void *argp1 = 0 ;
25719 int res1 = 0 ;
25720 bool val2 ;
25721 int ecode2 = 0 ;
25722 PyObject *swig_obj[2] ;
25723
25724 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25728 }
25729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25730 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25731 if (!SWIG_IsOK(ecode2)) {
25732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25733 }
25734 arg2 = static_cast< bool >(val2);
25735 if (arg1) (arg1)->m_scanCode = arg2;
25736
25737 resultobj = SWIG_Py_Void();
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25745 PyObject *resultobj = 0;
25746 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25747 bool result;
25748 void *argp1 = 0 ;
25749 int res1 = 0 ;
25750 PyObject *swig_obj[1] ;
25751
25752 if (!args) SWIG_fail;
25753 swig_obj[0] = args;
25754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25755 if (!SWIG_IsOK(res1)) {
25756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25757 }
25758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25759 result = (bool) ((arg1)->m_scanCode);
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *resultobj = 0;
25771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25772 unsigned int arg2 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 unsigned int val2 ;
25776 int ecode2 = 0 ;
25777 PyObject *swig_obj[2] ;
25778
25779 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25781 if (!SWIG_IsOK(res1)) {
25782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25783 }
25784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25785 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25786 if (!SWIG_IsOK(ecode2)) {
25787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25788 }
25789 arg2 = static_cast< unsigned int >(val2);
25790 if (arg1) (arg1)->m_rawCode = arg2;
25791
25792 resultobj = SWIG_Py_Void();
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25800 PyObject *resultobj = 0;
25801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25802 unsigned int result;
25803 void *argp1 = 0 ;
25804 int res1 = 0 ;
25805 PyObject *swig_obj[1] ;
25806
25807 if (!args) SWIG_fail;
25808 swig_obj[0] = args;
25809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25810 if (!SWIG_IsOK(res1)) {
25811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25812 }
25813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25814 result = (unsigned int) ((arg1)->m_rawCode);
25815 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25823 PyObject *resultobj = 0;
25824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25825 unsigned int arg2 ;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 unsigned int val2 ;
25829 int ecode2 = 0 ;
25830 PyObject *swig_obj[2] ;
25831
25832 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25834 if (!SWIG_IsOK(res1)) {
25835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25836 }
25837 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25838 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25839 if (!SWIG_IsOK(ecode2)) {
25840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25841 }
25842 arg2 = static_cast< unsigned int >(val2);
25843 if (arg1) (arg1)->m_rawFlags = arg2;
25844
25845 resultobj = SWIG_Py_Void();
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853 PyObject *resultobj = 0;
25854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25855 unsigned int result;
25856 void *argp1 = 0 ;
25857 int res1 = 0 ;
25858 PyObject *swig_obj[1] ;
25859
25860 if (!args) SWIG_fail;
25861 swig_obj[0] = args;
25862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25863 if (!SWIG_IsOK(res1)) {
25864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25865 }
25866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25867 result = (unsigned int) ((arg1)->m_rawFlags);
25868 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25876 PyObject *obj;
25877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25878 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25879 return SWIG_Py_Void();
25880 }
25881
25882 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25883 return SWIG_Python_InitShadowInstance(args);
25884 }
25885
25886 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25887 PyObject *resultobj = 0;
25888 wxSize const &arg1_defvalue = wxDefaultSize ;
25889 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25890 int arg2 = (int) 0 ;
25891 wxSizeEvent *result = 0 ;
25892 wxSize temp1 ;
25893 int val2 ;
25894 int ecode2 = 0 ;
25895 PyObject * obj0 = 0 ;
25896 PyObject * obj1 = 0 ;
25897 char * kwnames[] = {
25898 (char *) "sz",(char *) "winid", NULL
25899 };
25900
25901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25902 if (obj0) {
25903 {
25904 arg1 = &temp1;
25905 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25906 }
25907 }
25908 if (obj1) {
25909 ecode2 = SWIG_AsVal_int(obj1, &val2);
25910 if (!SWIG_IsOK(ecode2)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25912 }
25913 arg2 = static_cast< int >(val2);
25914 }
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25922 return resultobj;
25923 fail:
25924 return NULL;
25925 }
25926
25927
25928 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25929 PyObject *resultobj = 0;
25930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25931 wxSize result;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 PyObject *swig_obj[1] ;
25935
25936 if (!args) SWIG_fail;
25937 swig_obj[0] = args;
25938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25939 if (!SWIG_IsOK(res1)) {
25940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25941 }
25942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = ((wxSizeEvent const *)arg1)->GetSize();
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 PyObject *resultobj = 0;
25958 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25959 wxRect result;
25960 void *argp1 = 0 ;
25961 int res1 = 0 ;
25962 PyObject *swig_obj[1] ;
25963
25964 if (!args) SWIG_fail;
25965 swig_obj[0] = args;
25966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25969 }
25970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 result = ((wxSizeEvent const *)arg1)->GetRect();
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25985 PyObject *resultobj = 0;
25986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25987 wxRect arg2 ;
25988 void *argp1 = 0 ;
25989 int res1 = 0 ;
25990 void *argp2 ;
25991 int res2 = 0 ;
25992 PyObject * obj0 = 0 ;
25993 PyObject * obj1 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "rect", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26002 }
26003 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26004 {
26005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26006 if (!SWIG_IsOK(res2)) {
26007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26008 }
26009 if (!argp2) {
26010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26011 } else {
26012 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26013 arg2 = *temp;
26014 if (SWIG_IsNewObj(res2)) delete temp;
26015 }
26016 }
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 (arg1)->SetRect(arg2);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 resultobj = SWIG_Py_Void();
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26031 PyObject *resultobj = 0;
26032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26033 wxSize arg2 ;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 void *argp2 ;
26037 int res2 = 0 ;
26038 PyObject * obj0 = 0 ;
26039 PyObject * obj1 = 0 ;
26040 char * kwnames[] = {
26041 (char *) "self",(char *) "size", NULL
26042 };
26043
26044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26046 if (!SWIG_IsOK(res1)) {
26047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26048 }
26049 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26050 {
26051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26052 if (!SWIG_IsOK(res2)) {
26053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26054 }
26055 if (!argp2) {
26056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26057 } else {
26058 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26059 arg2 = *temp;
26060 if (SWIG_IsNewObj(res2)) delete temp;
26061 }
26062 }
26063 {
26064 PyThreadState* __tstate = wxPyBeginAllowThreads();
26065 wxSizeEvent_SetSize(arg1,arg2);
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 resultobj = SWIG_Py_Void();
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26077 PyObject *resultobj = 0;
26078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26079 wxSize *arg2 = (wxSize *) 0 ;
26080 void *argp1 = 0 ;
26081 int res1 = 0 ;
26082 void *argp2 = 0 ;
26083 int res2 = 0 ;
26084 PyObject *swig_obj[2] ;
26085
26086 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26090 }
26091 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26093 if (!SWIG_IsOK(res2)) {
26094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26095 }
26096 arg2 = reinterpret_cast< wxSize * >(argp2);
26097 if (arg1) (arg1)->m_size = *arg2;
26098
26099 resultobj = SWIG_Py_Void();
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26109 wxSize *result = 0 ;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26119 }
26120 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26121 result = (wxSize *)& ((arg1)->m_size);
26122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *resultobj = 0;
26131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26132 wxRect *arg2 = (wxRect *) 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 void *argp2 = 0 ;
26136 int res2 = 0 ;
26137 PyObject *swig_obj[2] ;
26138
26139 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26143 }
26144 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26146 if (!SWIG_IsOK(res2)) {
26147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26148 }
26149 arg2 = reinterpret_cast< wxRect * >(argp2);
26150 if (arg1) (arg1)->m_rect = *arg2;
26151
26152 resultobj = SWIG_Py_Void();
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26160 PyObject *resultobj = 0;
26161 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26162 wxRect *result = 0 ;
26163 void *argp1 = 0 ;
26164 int res1 = 0 ;
26165 PyObject *swig_obj[1] ;
26166
26167 if (!args) SWIG_fail;
26168 swig_obj[0] = args;
26169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26172 }
26173 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26174 result = (wxRect *)& ((arg1)->m_rect);
26175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26183 PyObject *obj;
26184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26185 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26186 return SWIG_Py_Void();
26187 }
26188
26189 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26190 return SWIG_Python_InitShadowInstance(args);
26191 }
26192
26193 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26194 PyObject *resultobj = 0;
26195 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26196 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26197 int arg2 = (int) 0 ;
26198 wxMoveEvent *result = 0 ;
26199 wxPoint temp1 ;
26200 int val2 ;
26201 int ecode2 = 0 ;
26202 PyObject * obj0 = 0 ;
26203 PyObject * obj1 = 0 ;
26204 char * kwnames[] = {
26205 (char *) "pos",(char *) "winid", NULL
26206 };
26207
26208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26209 if (obj0) {
26210 {
26211 arg1 = &temp1;
26212 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26213 }
26214 }
26215 if (obj1) {
26216 ecode2 = SWIG_AsVal_int(obj1, &val2);
26217 if (!SWIG_IsOK(ecode2)) {
26218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26219 }
26220 arg2 = static_cast< int >(val2);
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26236 PyObject *resultobj = 0;
26237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26238 wxPoint result;
26239 void *argp1 = 0 ;
26240 int res1 = 0 ;
26241 PyObject *swig_obj[1] ;
26242
26243 if (!args) SWIG_fail;
26244 swig_obj[0] = args;
26245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26246 if (!SWIG_IsOK(res1)) {
26247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26248 }
26249 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26250 {
26251 PyThreadState* __tstate = wxPyBeginAllowThreads();
26252 result = ((wxMoveEvent const *)arg1)->GetPosition();
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26264 PyObject *resultobj = 0;
26265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26266 wxRect result;
26267 void *argp1 = 0 ;
26268 int res1 = 0 ;
26269 PyObject *swig_obj[1] ;
26270
26271 if (!args) SWIG_fail;
26272 swig_obj[0] = args;
26273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26274 if (!SWIG_IsOK(res1)) {
26275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26276 }
26277 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26278 {
26279 PyThreadState* __tstate = wxPyBeginAllowThreads();
26280 result = ((wxMoveEvent const *)arg1)->GetRect();
26281 wxPyEndAllowThreads(__tstate);
26282 if (PyErr_Occurred()) SWIG_fail;
26283 }
26284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj = 0;
26293 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26294 wxRect *arg2 = 0 ;
26295 void *argp1 = 0 ;
26296 int res1 = 0 ;
26297 wxRect temp2 ;
26298 PyObject * obj0 = 0 ;
26299 PyObject * obj1 = 0 ;
26300 char * kwnames[] = {
26301 (char *) "self",(char *) "rect", NULL
26302 };
26303
26304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26306 if (!SWIG_IsOK(res1)) {
26307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26308 }
26309 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26310 {
26311 arg2 = &temp2;
26312 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26313 }
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 (arg1)->SetRect((wxRect const &)*arg2);
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 resultobj = SWIG_Py_Void();
26321 return resultobj;
26322 fail:
26323 return NULL;
26324 }
26325
26326
26327 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26328 PyObject *resultobj = 0;
26329 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26330 wxPoint *arg2 = 0 ;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 wxPoint temp2 ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char * kwnames[] = {
26337 (char *) "self",(char *) "pos", NULL
26338 };
26339
26340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26344 }
26345 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26346 {
26347 arg2 = &temp2;
26348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 (arg1)->SetPosition((wxPoint const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_Py_Void();
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *obj;
26365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26367 return SWIG_Py_Void();
26368 }
26369
26370 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26371 return SWIG_Python_InitShadowInstance(args);
26372 }
26373
26374 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26375 PyObject *resultobj = 0;
26376 int arg1 = (int) 0 ;
26377 wxPaintEvent *result = 0 ;
26378 int val1 ;
26379 int ecode1 = 0 ;
26380 PyObject * obj0 = 0 ;
26381 char * kwnames[] = {
26382 (char *) "Id", NULL
26383 };
26384
26385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26386 if (obj0) {
26387 ecode1 = SWIG_AsVal_int(obj0, &val1);
26388 if (!SWIG_IsOK(ecode1)) {
26389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26390 }
26391 arg1 = static_cast< int >(val1);
26392 }
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *obj;
26408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26410 return SWIG_Py_Void();
26411 }
26412
26413 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26414 return SWIG_Python_InitShadowInstance(args);
26415 }
26416
26417 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj = 0;
26419 int arg1 = (int) 0 ;
26420 wxNcPaintEvent *result = 0 ;
26421 int val1 ;
26422 int ecode1 = 0 ;
26423 PyObject * obj0 = 0 ;
26424 char * kwnames[] = {
26425 (char *) "winid", NULL
26426 };
26427
26428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26429 if (obj0) {
26430 ecode1 = SWIG_AsVal_int(obj0, &val1);
26431 if (!SWIG_IsOK(ecode1)) {
26432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26433 }
26434 arg1 = static_cast< int >(val1);
26435 }
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26450 PyObject *obj;
26451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26452 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26453 return SWIG_Py_Void();
26454 }
26455
26456 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 return SWIG_Python_InitShadowInstance(args);
26458 }
26459
26460 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26461 PyObject *resultobj = 0;
26462 int arg1 = (int) 0 ;
26463 wxDC *arg2 = (wxDC *) NULL ;
26464 wxEraseEvent *result = 0 ;
26465 int val1 ;
26466 int ecode1 = 0 ;
26467 void *argp2 = 0 ;
26468 int res2 = 0 ;
26469 PyObject * obj0 = 0 ;
26470 PyObject * obj1 = 0 ;
26471 char * kwnames[] = {
26472 (char *) "Id",(char *) "dc", NULL
26473 };
26474
26475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26476 if (obj0) {
26477 ecode1 = SWIG_AsVal_int(obj0, &val1);
26478 if (!SWIG_IsOK(ecode1)) {
26479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26480 }
26481 arg1 = static_cast< int >(val1);
26482 }
26483 if (obj1) {
26484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26485 if (!SWIG_IsOK(res2)) {
26486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26487 }
26488 arg2 = reinterpret_cast< wxDC * >(argp2);
26489 }
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26504 PyObject *resultobj = 0;
26505 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26506 wxDC *result = 0 ;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 PyObject *swig_obj[1] ;
26510
26511 if (!args) SWIG_fail;
26512 swig_obj[0] = args;
26513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26516 }
26517 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 {
26525 resultobj = wxPyMake_wxObject(result, (bool)0);
26526 }
26527 return resultobj;
26528 fail:
26529 return NULL;
26530 }
26531
26532
26533 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26534 PyObject *obj;
26535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26536 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26537 return SWIG_Py_Void();
26538 }
26539
26540 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26541 return SWIG_Python_InitShadowInstance(args);
26542 }
26543
26544 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj = 0;
26546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26547 int arg2 = (int) 0 ;
26548 wxFocusEvent *result = 0 ;
26549 int val1 ;
26550 int ecode1 = 0 ;
26551 int val2 ;
26552 int ecode2 = 0 ;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555 char * kwnames[] = {
26556 (char *) "type",(char *) "winid", NULL
26557 };
26558
26559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26560 if (obj0) {
26561 ecode1 = SWIG_AsVal_int(obj0, &val1);
26562 if (!SWIG_IsOK(ecode1)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26564 }
26565 arg1 = static_cast< wxEventType >(val1);
26566 }
26567 if (obj1) {
26568 ecode2 = SWIG_AsVal_int(obj1, &val2);
26569 if (!SWIG_IsOK(ecode2)) {
26570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26571 }
26572 arg2 = static_cast< int >(val2);
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26581 return resultobj;
26582 fail:
26583 return NULL;
26584 }
26585
26586
26587 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26588 PyObject *resultobj = 0;
26589 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26590 wxWindow *result = 0 ;
26591 void *argp1 = 0 ;
26592 int res1 = 0 ;
26593 PyObject *swig_obj[1] ;
26594
26595 if (!args) SWIG_fail;
26596 swig_obj[0] = args;
26597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26598 if (!SWIG_IsOK(res1)) {
26599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26600 }
26601 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 {
26609 resultobj = wxPyMake_wxObject(result, (bool)0);
26610 }
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26620 wxWindow *arg2 = (wxWindow *) 0 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 void *argp2 = 0 ;
26624 int res2 = 0 ;
26625 PyObject * obj0 = 0 ;
26626 PyObject * obj1 = 0 ;
26627 char * kwnames[] = {
26628 (char *) "self",(char *) "win", NULL
26629 };
26630
26631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26635 }
26636 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26638 if (!SWIG_IsOK(res2)) {
26639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26640 }
26641 arg2 = reinterpret_cast< wxWindow * >(argp2);
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 (arg1)->SetWindow(arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_Py_Void();
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 PyObject *obj;
26657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26658 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26659 return SWIG_Py_Void();
26660 }
26661
26662 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26663 return SWIG_Python_InitShadowInstance(args);
26664 }
26665
26666 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj = 0;
26668 wxWindow *arg1 = (wxWindow *) NULL ;
26669 wxChildFocusEvent *result = 0 ;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 PyObject * obj0 = 0 ;
26673 char * kwnames[] = {
26674 (char *) "win", NULL
26675 };
26676
26677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26678 if (obj0) {
26679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26680 if (!SWIG_IsOK(res1)) {
26681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26682 }
26683 arg1 = reinterpret_cast< wxWindow * >(argp1);
26684 }
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26699 PyObject *resultobj = 0;
26700 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26701 wxWindow *result = 0 ;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject *swig_obj[1] ;
26705
26706 if (!args) SWIG_fail;
26707 swig_obj[0] = args;
26708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26709 if (!SWIG_IsOK(res1)) {
26710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26711 }
26712 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 {
26720 resultobj = wxPyMake_wxObject(result, (bool)0);
26721 }
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26729 PyObject *obj;
26730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26731 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26732 return SWIG_Py_Void();
26733 }
26734
26735 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26736 return SWIG_Python_InitShadowInstance(args);
26737 }
26738
26739 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26740 PyObject *resultobj = 0;
26741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26742 bool arg2 = (bool) true ;
26743 int arg3 = (int) 0 ;
26744 wxActivateEvent *result = 0 ;
26745 int val1 ;
26746 int ecode1 = 0 ;
26747 bool val2 ;
26748 int ecode2 = 0 ;
26749 int val3 ;
26750 int ecode3 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 PyObject * obj2 = 0 ;
26754 char * kwnames[] = {
26755 (char *) "type",(char *) "active",(char *) "Id", NULL
26756 };
26757
26758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26759 if (obj0) {
26760 ecode1 = SWIG_AsVal_int(obj0, &val1);
26761 if (!SWIG_IsOK(ecode1)) {
26762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26763 }
26764 arg1 = static_cast< wxEventType >(val1);
26765 }
26766 if (obj1) {
26767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26770 }
26771 arg2 = static_cast< bool >(val2);
26772 }
26773 if (obj2) {
26774 ecode3 = SWIG_AsVal_int(obj2, &val3);
26775 if (!SWIG_IsOK(ecode3)) {
26776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26777 }
26778 arg3 = static_cast< int >(val3);
26779 }
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 PyObject *resultobj = 0;
26795 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26796 bool result;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 PyObject *swig_obj[1] ;
26800
26801 if (!args) SWIG_fail;
26802 swig_obj[0] = args;
26803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26806 }
26807 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 {
26815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26816 }
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26824 PyObject *obj;
26825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26826 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26827 return SWIG_Py_Void();
26828 }
26829
26830 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26831 return SWIG_Python_InitShadowInstance(args);
26832 }
26833
26834 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj = 0;
26836 int arg1 = (int) 0 ;
26837 wxInitDialogEvent *result = 0 ;
26838 int val1 ;
26839 int ecode1 = 0 ;
26840 PyObject * obj0 = 0 ;
26841 char * kwnames[] = {
26842 (char *) "Id", NULL
26843 };
26844
26845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26846 if (obj0) {
26847 ecode1 = SWIG_AsVal_int(obj0, &val1);
26848 if (!SWIG_IsOK(ecode1)) {
26849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26850 }
26851 arg1 = static_cast< int >(val1);
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26860 return resultobj;
26861 fail:
26862 return NULL;
26863 }
26864
26865
26866 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26867 PyObject *obj;
26868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26869 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26870 return SWIG_Py_Void();
26871 }
26872
26873 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26874 return SWIG_Python_InitShadowInstance(args);
26875 }
26876
26877 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj = 0;
26879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26880 int arg2 = (int) 0 ;
26881 wxMenu *arg3 = (wxMenu *) NULL ;
26882 wxMenuEvent *result = 0 ;
26883 int val1 ;
26884 int ecode1 = 0 ;
26885 int val2 ;
26886 int ecode2 = 0 ;
26887 void *argp3 = 0 ;
26888 int res3 = 0 ;
26889 PyObject * obj0 = 0 ;
26890 PyObject * obj1 = 0 ;
26891 PyObject * obj2 = 0 ;
26892 char * kwnames[] = {
26893 (char *) "type",(char *) "winid",(char *) "menu", NULL
26894 };
26895
26896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26897 if (obj0) {
26898 ecode1 = SWIG_AsVal_int(obj0, &val1);
26899 if (!SWIG_IsOK(ecode1)) {
26900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26901 }
26902 arg1 = static_cast< wxEventType >(val1);
26903 }
26904 if (obj1) {
26905 ecode2 = SWIG_AsVal_int(obj1, &val2);
26906 if (!SWIG_IsOK(ecode2)) {
26907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26908 }
26909 arg2 = static_cast< int >(val2);
26910 }
26911 if (obj2) {
26912 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26913 if (!SWIG_IsOK(res3)) {
26914 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26915 }
26916 arg3 = reinterpret_cast< wxMenu * >(argp3);
26917 }
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26932 PyObject *resultobj = 0;
26933 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26934 int result;
26935 void *argp1 = 0 ;
26936 int res1 = 0 ;
26937 PyObject *swig_obj[1] ;
26938
26939 if (!args) SWIG_fail;
26940 swig_obj[0] = args;
26941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26942 if (!SWIG_IsOK(res1)) {
26943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26944 }
26945 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26946 {
26947 PyThreadState* __tstate = wxPyBeginAllowThreads();
26948 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 resultobj = SWIG_From_int(static_cast< int >(result));
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26960 PyObject *resultobj = 0;
26961 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26962 bool result;
26963 void *argp1 = 0 ;
26964 int res1 = 0 ;
26965 PyObject *swig_obj[1] ;
26966
26967 if (!args) SWIG_fail;
26968 swig_obj[0] = args;
26969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26970 if (!SWIG_IsOK(res1)) {
26971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26972 }
26973 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 {
26981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26990 PyObject *resultobj = 0;
26991 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26992 wxMenu *result = 0 ;
26993 void *argp1 = 0 ;
26994 int res1 = 0 ;
26995 PyObject *swig_obj[1] ;
26996
26997 if (!args) SWIG_fail;
26998 swig_obj[0] = args;
26999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27000 if (!SWIG_IsOK(res1)) {
27001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27002 }
27003 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27007 wxPyEndAllowThreads(__tstate);
27008 if (PyErr_Occurred()) SWIG_fail;
27009 }
27010 {
27011 resultobj = wxPyMake_wxObject(result, (bool)0);
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27020 PyObject *obj;
27021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27022 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27023 return SWIG_Py_Void();
27024 }
27025
27026 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27027 return SWIG_Python_InitShadowInstance(args);
27028 }
27029
27030 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj = 0;
27032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27033 int arg2 = (int) 0 ;
27034 wxCloseEvent *result = 0 ;
27035 int val1 ;
27036 int ecode1 = 0 ;
27037 int val2 ;
27038 int ecode2 = 0 ;
27039 PyObject * obj0 = 0 ;
27040 PyObject * obj1 = 0 ;
27041 char * kwnames[] = {
27042 (char *) "type",(char *) "winid", NULL
27043 };
27044
27045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27046 if (obj0) {
27047 ecode1 = SWIG_AsVal_int(obj0, &val1);
27048 if (!SWIG_IsOK(ecode1)) {
27049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27050 }
27051 arg1 = static_cast< wxEventType >(val1);
27052 }
27053 if (obj1) {
27054 ecode2 = SWIG_AsVal_int(obj1, &val2);
27055 if (!SWIG_IsOK(ecode2)) {
27056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27057 }
27058 arg2 = static_cast< int >(val2);
27059 }
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj = 0;
27075 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27076 bool arg2 ;
27077 void *argp1 = 0 ;
27078 int res1 = 0 ;
27079 bool val2 ;
27080 int ecode2 = 0 ;
27081 PyObject * obj0 = 0 ;
27082 PyObject * obj1 = 0 ;
27083 char * kwnames[] = {
27084 (char *) "self",(char *) "logOff", NULL
27085 };
27086
27087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27089 if (!SWIG_IsOK(res1)) {
27090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27091 }
27092 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27093 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27094 if (!SWIG_IsOK(ecode2)) {
27095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27096 }
27097 arg2 = static_cast< bool >(val2);
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 (arg1)->SetLoggingOff(arg2);
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 resultobj = SWIG_Py_Void();
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27112 PyObject *resultobj = 0;
27113 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27114 bool result;
27115 void *argp1 = 0 ;
27116 int res1 = 0 ;
27117 PyObject *swig_obj[1] ;
27118
27119 if (!args) SWIG_fail;
27120 swig_obj[0] = args;
27121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27122 if (!SWIG_IsOK(res1)) {
27123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27124 }
27125 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 {
27133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27134 }
27135 return resultobj;
27136 fail:
27137 return NULL;
27138 }
27139
27140
27141 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27142 PyObject *resultobj = 0;
27143 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27144 bool arg2 = (bool) true ;
27145 void *argp1 = 0 ;
27146 int res1 = 0 ;
27147 bool val2 ;
27148 int ecode2 = 0 ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "veto", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27159 }
27160 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27161 if (obj1) {
27162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27163 if (!SWIG_IsOK(ecode2)) {
27164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27165 }
27166 arg2 = static_cast< bool >(val2);
27167 }
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 (arg1)->Veto(arg2);
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 resultobj = SWIG_Py_Void();
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27182 PyObject *resultobj = 0;
27183 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27184 bool result;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 PyObject *swig_obj[1] ;
27188
27189 if (!args) SWIG_fail;
27190 swig_obj[0] = args;
27191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27194 }
27195 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 {
27203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27204 }
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj = 0;
27213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27214 bool arg2 ;
27215 void *argp1 = 0 ;
27216 int res1 = 0 ;
27217 bool val2 ;
27218 int ecode2 = 0 ;
27219 PyObject * obj0 = 0 ;
27220 PyObject * obj1 = 0 ;
27221 char * kwnames[] = {
27222 (char *) "self",(char *) "canVeto", NULL
27223 };
27224
27225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27227 if (!SWIG_IsOK(res1)) {
27228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27229 }
27230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27232 if (!SWIG_IsOK(ecode2)) {
27233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27234 }
27235 arg2 = static_cast< bool >(val2);
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 (arg1)->SetCanVeto(arg2);
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 resultobj = SWIG_Py_Void();
27243 return resultobj;
27244 fail:
27245 return NULL;
27246 }
27247
27248
27249 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27250 PyObject *resultobj = 0;
27251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27252 bool result;
27253 void *argp1 = 0 ;
27254 int res1 = 0 ;
27255 PyObject *swig_obj[1] ;
27256
27257 if (!args) SWIG_fail;
27258 swig_obj[0] = args;
27259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27260 if (!SWIG_IsOK(res1)) {
27261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27262 }
27263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 {
27271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27272 }
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27280 PyObject *obj;
27281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27282 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27283 return SWIG_Py_Void();
27284 }
27285
27286 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27287 return SWIG_Python_InitShadowInstance(args);
27288 }
27289
27290 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj = 0;
27292 int arg1 = (int) 0 ;
27293 bool arg2 = (bool) false ;
27294 wxShowEvent *result = 0 ;
27295 int val1 ;
27296 int ecode1 = 0 ;
27297 bool val2 ;
27298 int ecode2 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "winid",(char *) "show", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27306 if (obj0) {
27307 ecode1 = SWIG_AsVal_int(obj0, &val1);
27308 if (!SWIG_IsOK(ecode1)) {
27309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27310 }
27311 arg1 = static_cast< int >(val1);
27312 }
27313 if (obj1) {
27314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27315 if (!SWIG_IsOK(ecode2)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27317 }
27318 arg2 = static_cast< bool >(val2);
27319 }
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27334 PyObject *resultobj = 0;
27335 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27336 bool arg2 ;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 bool val2 ;
27340 int ecode2 = 0 ;
27341 PyObject * obj0 = 0 ;
27342 PyObject * obj1 = 0 ;
27343 char * kwnames[] = {
27344 (char *) "self",(char *) "show", NULL
27345 };
27346
27347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27351 }
27352 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27354 if (!SWIG_IsOK(ecode2)) {
27355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27356 }
27357 arg2 = static_cast< bool >(val2);
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 (arg1)->SetShow(arg2);
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_Py_Void();
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27372 PyObject *resultobj = 0;
27373 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27374 bool result;
27375 void *argp1 = 0 ;
27376 int res1 = 0 ;
27377 PyObject *swig_obj[1] ;
27378
27379 if (!args) SWIG_fail;
27380 swig_obj[0] = args;
27381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27384 }
27385 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27389 wxPyEndAllowThreads(__tstate);
27390 if (PyErr_Occurred()) SWIG_fail;
27391 }
27392 {
27393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27394 }
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 PyObject *obj;
27403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27404 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27405 return SWIG_Py_Void();
27406 }
27407
27408 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27409 return SWIG_Python_InitShadowInstance(args);
27410 }
27411
27412 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj = 0;
27414 int arg1 = (int) 0 ;
27415 bool arg2 = (bool) true ;
27416 wxIconizeEvent *result = 0 ;
27417 int val1 ;
27418 int ecode1 = 0 ;
27419 bool val2 ;
27420 int ecode2 = 0 ;
27421 PyObject * obj0 = 0 ;
27422 PyObject * obj1 = 0 ;
27423 char * kwnames[] = {
27424 (char *) "id",(char *) "iconized", NULL
27425 };
27426
27427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27428 if (obj0) {
27429 ecode1 = SWIG_AsVal_int(obj0, &val1);
27430 if (!SWIG_IsOK(ecode1)) {
27431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27432 }
27433 arg1 = static_cast< int >(val1);
27434 }
27435 if (obj1) {
27436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27437 if (!SWIG_IsOK(ecode2)) {
27438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27439 }
27440 arg2 = static_cast< bool >(val2);
27441 }
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27456 PyObject *resultobj = 0;
27457 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27458 bool result;
27459 void *argp1 = 0 ;
27460 int res1 = 0 ;
27461 PyObject *swig_obj[1] ;
27462
27463 if (!args) SWIG_fail;
27464 swig_obj[0] = args;
27465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27466 if (!SWIG_IsOK(res1)) {
27467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27468 }
27469 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = (bool)(arg1)->Iconized();
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 {
27477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27478 }
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *obj;
27487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27488 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27489 return SWIG_Py_Void();
27490 }
27491
27492 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27493 return SWIG_Python_InitShadowInstance(args);
27494 }
27495
27496 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27497 PyObject *resultobj = 0;
27498 int arg1 = (int) 0 ;
27499 wxMaximizeEvent *result = 0 ;
27500 int val1 ;
27501 int ecode1 = 0 ;
27502 PyObject * obj0 = 0 ;
27503 char * kwnames[] = {
27504 (char *) "id", NULL
27505 };
27506
27507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27508 if (obj0) {
27509 ecode1 = SWIG_AsVal_int(obj0, &val1);
27510 if (!SWIG_IsOK(ecode1)) {
27511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27512 }
27513 arg1 = static_cast< int >(val1);
27514 }
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27529 PyObject *obj;
27530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27531 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27532 return SWIG_Py_Void();
27533 }
27534
27535 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27536 return SWIG_Python_InitShadowInstance(args);
27537 }
27538
27539 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27540 PyObject *resultobj = 0;
27541 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27542 wxPoint result;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 PyObject *swig_obj[1] ;
27546
27547 if (!args) SWIG_fail;
27548 swig_obj[0] = args;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27552 }
27553 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (arg1)->GetPosition();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27570 int result;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 PyObject *swig_obj[1] ;
27574
27575 if (!args) SWIG_fail;
27576 swig_obj[0] = args;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27580 }
27581 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (int)(arg1)->GetNumberOfFiles();
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_From_int(static_cast< int >(result));
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27598 PyObject *result = 0 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27608 }
27609 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 resultobj = result;
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27624 PyObject *obj;
27625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27626 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27627 return SWIG_Py_Void();
27628 }
27629
27630 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj = 0;
27632 int arg1 = (int) 0 ;
27633 wxUpdateUIEvent *result = 0 ;
27634 int val1 ;
27635 int ecode1 = 0 ;
27636 PyObject * obj0 = 0 ;
27637 char * kwnames[] = {
27638 (char *) "commandId", NULL
27639 };
27640
27641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27642 if (obj0) {
27643 ecode1 = SWIG_AsVal_int(obj0, &val1);
27644 if (!SWIG_IsOK(ecode1)) {
27645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27646 }
27647 arg1 = static_cast< int >(val1);
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27665 bool result;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27675 }
27676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27693 PyObject *resultobj = 0;
27694 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27695 bool result;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 PyObject *swig_obj[1] ;
27699
27700 if (!args) SWIG_fail;
27701 swig_obj[0] = args;
27702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27703 if (!SWIG_IsOK(res1)) {
27704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27705 }
27706 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 {
27714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27715 }
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *resultobj = 0;
27724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27725 bool result;
27726 void *argp1 = 0 ;
27727 int res1 = 0 ;
27728 PyObject *swig_obj[1] ;
27729
27730 if (!args) SWIG_fail;
27731 swig_obj[0] = args;
27732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27735 }
27736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27753 PyObject *resultobj = 0;
27754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27755 wxString result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 PyObject *swig_obj[1] ;
27759
27760 if (!args) SWIG_fail;
27761 swig_obj[0] = args;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27765 }
27766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 {
27774 #if wxUSE_UNICODE
27775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27776 #else
27777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27778 #endif
27779 }
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27787 PyObject *resultobj = 0;
27788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27789 bool result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 PyObject *swig_obj[1] ;
27793
27794 if (!args) SWIG_fail;
27795 swig_obj[0] = args;
27796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27799 }
27800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27817 PyObject *resultobj = 0;
27818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27819 bool result;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 PyObject *swig_obj[1] ;
27823
27824 if (!args) SWIG_fail;
27825 swig_obj[0] = args;
27826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27827 if (!SWIG_IsOK(res1)) {
27828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27829 }
27830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 {
27838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27839 }
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27847 PyObject *resultobj = 0;
27848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27849 bool result;
27850 void *argp1 = 0 ;
27851 int res1 = 0 ;
27852 PyObject *swig_obj[1] ;
27853
27854 if (!args) SWIG_fail;
27855 swig_obj[0] = args;
27856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27857 if (!SWIG_IsOK(res1)) {
27858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27859 }
27860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27869 }
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27877 PyObject *resultobj = 0;
27878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27879 bool result;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 PyObject *swig_obj[1] ;
27883
27884 if (!args) SWIG_fail;
27885 swig_obj[0] = args;
27886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27887 if (!SWIG_IsOK(res1)) {
27888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27889 }
27890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27891 {
27892 PyThreadState* __tstate = wxPyBeginAllowThreads();
27893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27894 wxPyEndAllowThreads(__tstate);
27895 if (PyErr_Occurred()) SWIG_fail;
27896 }
27897 {
27898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27899 }
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27907 PyObject *resultobj = 0;
27908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27909 bool arg2 ;
27910 void *argp1 = 0 ;
27911 int res1 = 0 ;
27912 bool val2 ;
27913 int ecode2 = 0 ;
27914 PyObject * obj0 = 0 ;
27915 PyObject * obj1 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "self",(char *) "check", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27924 }
27925 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27927 if (!SWIG_IsOK(ecode2)) {
27928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27929 }
27930 arg2 = static_cast< bool >(val2);
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 (arg1)->Check(arg2);
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 resultobj = SWIG_Py_Void();
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = 0;
27946 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27947 bool arg2 ;
27948 void *argp1 = 0 ;
27949 int res1 = 0 ;
27950 bool val2 ;
27951 int ecode2 = 0 ;
27952 PyObject * obj0 = 0 ;
27953 PyObject * obj1 = 0 ;
27954 char * kwnames[] = {
27955 (char *) "self",(char *) "enable", NULL
27956 };
27957
27958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27962 }
27963 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27965 if (!SWIG_IsOK(ecode2)) {
27966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27967 }
27968 arg2 = static_cast< bool >(val2);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 (arg1)->Enable(arg2);
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 resultobj = SWIG_Py_Void();
27976 return resultobj;
27977 fail:
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27985 bool arg2 ;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 bool val2 ;
27989 int ecode2 = 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "show", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28000 }
28001 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28003 if (!SWIG_IsOK(ecode2)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28005 }
28006 arg2 = static_cast< bool >(val2);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 (arg1)->Show(arg2);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_Py_Void();
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj = 0;
28022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28023 wxString *arg2 = 0 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 bool temp2 = false ;
28027 PyObject * obj0 = 0 ;
28028 PyObject * obj1 = 0 ;
28029 char * kwnames[] = {
28030 (char *) "self",(char *) "text", NULL
28031 };
28032
28033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28035 if (!SWIG_IsOK(res1)) {
28036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28037 }
28038 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28039 {
28040 arg2 = wxString_in_helper(obj1);
28041 if (arg2 == NULL) SWIG_fail;
28042 temp2 = true;
28043 }
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 (arg1)->SetText((wxString const &)*arg2);
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 resultobj = SWIG_Py_Void();
28051 {
28052 if (temp2)
28053 delete arg2;
28054 }
28055 return resultobj;
28056 fail:
28057 {
28058 if (temp2)
28059 delete arg2;
28060 }
28061 return NULL;
28062 }
28063
28064
28065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj = 0;
28067 long arg1 ;
28068 long val1 ;
28069 int ecode1 = 0 ;
28070 PyObject * obj0 = 0 ;
28071 char * kwnames[] = {
28072 (char *) "updateInterval", NULL
28073 };
28074
28075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28076 ecode1 = SWIG_AsVal_long(obj0, &val1);
28077 if (!SWIG_IsOK(ecode1)) {
28078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28079 }
28080 arg1 = static_cast< long >(val1);
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 wxUpdateUIEvent::SetUpdateInterval(arg1);
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_Py_Void();
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 long result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_From_long(static_cast< long >(result));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = 0;
28114 wxWindow *arg1 = (wxWindow *) 0 ;
28115 bool result;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 PyObject * obj0 = 0 ;
28119 char * kwnames[] = {
28120 (char *) "win", NULL
28121 };
28122
28123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28125 if (!SWIG_IsOK(res1)) {
28126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28127 }
28128 arg1 = reinterpret_cast< wxWindow * >(argp1);
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 {
28136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28137 }
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28145 PyObject *resultobj = 0;
28146
28147 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxUpdateUIEvent::ResetUpdateTime();
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxUpdateUIMode arg1 ;
28164 int val1 ;
28165 int ecode1 = 0 ;
28166 PyObject * obj0 = 0 ;
28167 char * kwnames[] = {
28168 (char *) "mode", NULL
28169 };
28170
28171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28172 ecode1 = SWIG_AsVal_int(obj0, &val1);
28173 if (!SWIG_IsOK(ecode1)) {
28174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28175 }
28176 arg1 = static_cast< wxUpdateUIMode >(val1);
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 wxUpdateUIEvent::SetMode(arg1);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_Py_Void();
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28191 PyObject *resultobj = 0;
28192 wxUpdateUIMode result;
28193
28194 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_From_int(static_cast< int >(result));
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 PyObject *obj;
28210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28211 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28212 return SWIG_Py_Void();
28213 }
28214
28215 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28216 return SWIG_Python_InitShadowInstance(args);
28217 }
28218
28219 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28220 PyObject *resultobj = 0;
28221 wxSysColourChangedEvent *result = 0 ;
28222
28223 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *obj;
28239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28240 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28241 return SWIG_Py_Void();
28242 }
28243
28244 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28245 return SWIG_Python_InitShadowInstance(args);
28246 }
28247
28248 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28249 PyObject *resultobj = 0;
28250 int arg1 = (int) 0 ;
28251 wxWindow *arg2 = (wxWindow *) NULL ;
28252 wxMouseCaptureChangedEvent *result = 0 ;
28253 int val1 ;
28254 int ecode1 = 0 ;
28255 void *argp2 = 0 ;
28256 int res2 = 0 ;
28257 PyObject * obj0 = 0 ;
28258 PyObject * obj1 = 0 ;
28259 char * kwnames[] = {
28260 (char *) "winid",(char *) "gainedCapture", NULL
28261 };
28262
28263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28264 if (obj0) {
28265 ecode1 = SWIG_AsVal_int(obj0, &val1);
28266 if (!SWIG_IsOK(ecode1)) {
28267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28268 }
28269 arg1 = static_cast< int >(val1);
28270 }
28271 if (obj1) {
28272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28273 if (!SWIG_IsOK(res2)) {
28274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28275 }
28276 arg2 = reinterpret_cast< wxWindow * >(argp2);
28277 }
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28292 PyObject *resultobj = 0;
28293 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28294 wxWindow *result = 0 ;
28295 void *argp1 = 0 ;
28296 int res1 = 0 ;
28297 PyObject *swig_obj[1] ;
28298
28299 if (!args) SWIG_fail;
28300 swig_obj[0] = args;
28301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28304 }
28305 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 {
28313 resultobj = wxPyMake_wxObject(result, (bool)0);
28314 }
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28322 PyObject *obj;
28323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28324 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28325 return SWIG_Py_Void();
28326 }
28327
28328 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 return SWIG_Python_InitShadowInstance(args);
28330 }
28331
28332 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj = 0;
28334 int arg1 = (int) 0 ;
28335 wxMouseCaptureLostEvent *result = 0 ;
28336 int val1 ;
28337 int ecode1 = 0 ;
28338 PyObject * obj0 = 0 ;
28339 char * kwnames[] = {
28340 (char *) "winid", NULL
28341 };
28342
28343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28344 if (obj0) {
28345 ecode1 = SWIG_AsVal_int(obj0, &val1);
28346 if (!SWIG_IsOK(ecode1)) {
28347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28348 }
28349 arg1 = static_cast< int >(val1);
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28365 PyObject *obj;
28366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28367 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28368 return SWIG_Py_Void();
28369 }
28370
28371 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28372 return SWIG_Python_InitShadowInstance(args);
28373 }
28374
28375 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28376 PyObject *resultobj = 0;
28377 wxDisplayChangedEvent *result = 0 ;
28378
28379 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28387 return resultobj;
28388 fail:
28389 return NULL;
28390 }
28391
28392
28393 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28394 PyObject *obj;
28395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28396 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28397 return SWIG_Py_Void();
28398 }
28399
28400 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401 return SWIG_Python_InitShadowInstance(args);
28402 }
28403
28404 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj = 0;
28406 int arg1 = (int) 0 ;
28407 wxPaletteChangedEvent *result = 0 ;
28408 int val1 ;
28409 int ecode1 = 0 ;
28410 PyObject * obj0 = 0 ;
28411 char * kwnames[] = {
28412 (char *) "id", NULL
28413 };
28414
28415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28416 if (obj0) {
28417 ecode1 = SWIG_AsVal_int(obj0, &val1);
28418 if (!SWIG_IsOK(ecode1)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28420 }
28421 arg1 = static_cast< int >(val1);
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj = 0;
28438 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28439 wxWindow *arg2 = (wxWindow *) 0 ;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 void *argp2 = 0 ;
28443 int res2 = 0 ;
28444 PyObject * obj0 = 0 ;
28445 PyObject * obj1 = 0 ;
28446 char * kwnames[] = {
28447 (char *) "self",(char *) "win", NULL
28448 };
28449
28450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28452 if (!SWIG_IsOK(res1)) {
28453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28454 }
28455 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28457 if (!SWIG_IsOK(res2)) {
28458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28459 }
28460 arg2 = reinterpret_cast< wxWindow * >(argp2);
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 (arg1)->SetChangedWindow(arg2);
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_Py_Void();
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28477 wxWindow *result = 0 ;
28478 void *argp1 = 0 ;
28479 int res1 = 0 ;
28480 PyObject *swig_obj[1] ;
28481
28482 if (!args) SWIG_fail;
28483 swig_obj[0] = args;
28484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28485 if (!SWIG_IsOK(res1)) {
28486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28487 }
28488 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (wxWindow *)(arg1)->GetChangedWindow();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = wxPyMake_wxObject(result, (bool)0);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *obj;
28506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28507 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28508 return SWIG_Py_Void();
28509 }
28510
28511 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28512 return SWIG_Python_InitShadowInstance(args);
28513 }
28514
28515 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28516 PyObject *resultobj = 0;
28517 int arg1 = (int) 0 ;
28518 wxQueryNewPaletteEvent *result = 0 ;
28519 int val1 ;
28520 int ecode1 = 0 ;
28521 PyObject * obj0 = 0 ;
28522 char * kwnames[] = {
28523 (char *) "winid", NULL
28524 };
28525
28526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28527 if (obj0) {
28528 ecode1 = SWIG_AsVal_int(obj0, &val1);
28529 if (!SWIG_IsOK(ecode1)) {
28530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28531 }
28532 arg1 = static_cast< int >(val1);
28533 }
28534 {
28535 PyThreadState* __tstate = wxPyBeginAllowThreads();
28536 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28537 wxPyEndAllowThreads(__tstate);
28538 if (PyErr_Occurred()) SWIG_fail;
28539 }
28540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28548 PyObject *resultobj = 0;
28549 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28550 bool arg2 ;
28551 void *argp1 = 0 ;
28552 int res1 = 0 ;
28553 bool val2 ;
28554 int ecode2 = 0 ;
28555 PyObject * obj0 = 0 ;
28556 PyObject * obj1 = 0 ;
28557 char * kwnames[] = {
28558 (char *) "self",(char *) "realized", NULL
28559 };
28560
28561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28563 if (!SWIG_IsOK(res1)) {
28564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28565 }
28566 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28568 if (!SWIG_IsOK(ecode2)) {
28569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28570 }
28571 arg2 = static_cast< bool >(val2);
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->SetPaletteRealized(arg2);
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_Py_Void();
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28588 bool result;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28598 }
28599 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *obj;
28617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28618 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28619 return SWIG_Py_Void();
28620 }
28621
28622 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28623 return SWIG_Python_InitShadowInstance(args);
28624 }
28625
28626 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 PyObject *resultobj = 0;
28628 wxNavigationKeyEvent *result = 0 ;
28629
28630 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28647 bool result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28657 }
28658 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28667 }
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj = 0;
28676 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28677 bool arg2 ;
28678 void *argp1 = 0 ;
28679 int res1 = 0 ;
28680 bool val2 ;
28681 int ecode2 = 0 ;
28682 PyObject * obj0 = 0 ;
28683 PyObject * obj1 = 0 ;
28684 char * kwnames[] = {
28685 (char *) "self",(char *) "forward", NULL
28686 };
28687
28688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28690 if (!SWIG_IsOK(res1)) {
28691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28692 }
28693 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28694 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28695 if (!SWIG_IsOK(ecode2)) {
28696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28697 }
28698 arg2 = static_cast< bool >(val2);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 (arg1)->SetDirection(arg2);
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_Py_Void();
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28713 PyObject *resultobj = 0;
28714 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28715 bool result;
28716 void *argp1 = 0 ;
28717 int res1 = 0 ;
28718 PyObject *swig_obj[1] ;
28719
28720 if (!args) SWIG_fail;
28721 swig_obj[0] = args;
28722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28725 }
28726 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 {
28734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28735 }
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = 0;
28744 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28745 bool arg2 ;
28746 void *argp1 = 0 ;
28747 int res1 = 0 ;
28748 bool val2 ;
28749 int ecode2 = 0 ;
28750 PyObject * obj0 = 0 ;
28751 PyObject * obj1 = 0 ;
28752 char * kwnames[] = {
28753 (char *) "self",(char *) "ischange", NULL
28754 };
28755
28756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28760 }
28761 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28763 if (!SWIG_IsOK(ecode2)) {
28764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28765 }
28766 arg2 = static_cast< bool >(val2);
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 (arg1)->SetWindowChange(arg2);
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_Py_Void();
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28783 bool result;
28784 void *argp1 = 0 ;
28785 int res1 = 0 ;
28786 PyObject *swig_obj[1] ;
28787
28788 if (!args) SWIG_fail;
28789 swig_obj[0] = args;
28790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28793 }
28794 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 {
28802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28803 }
28804 return resultobj;
28805 fail:
28806 return NULL;
28807 }
28808
28809
28810 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28811 PyObject *resultobj = 0;
28812 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28813 bool arg2 ;
28814 void *argp1 = 0 ;
28815 int res1 = 0 ;
28816 bool val2 ;
28817 int ecode2 = 0 ;
28818 PyObject * obj0 = 0 ;
28819 PyObject * obj1 = 0 ;
28820 char * kwnames[] = {
28821 (char *) "self",(char *) "bIs", NULL
28822 };
28823
28824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28826 if (!SWIG_IsOK(res1)) {
28827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28828 }
28829 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28830 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28831 if (!SWIG_IsOK(ecode2)) {
28832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28833 }
28834 arg2 = static_cast< bool >(val2);
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 (arg1)->SetFromTab(arg2);
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 resultobj = SWIG_Py_Void();
28842 return resultobj;
28843 fail:
28844 return NULL;
28845 }
28846
28847
28848 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28849 PyObject *resultobj = 0;
28850 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28851 long arg2 ;
28852 void *argp1 = 0 ;
28853 int res1 = 0 ;
28854 long val2 ;
28855 int ecode2 = 0 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 char * kwnames[] = {
28859 (char *) "self",(char *) "flags", NULL
28860 };
28861
28862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28864 if (!SWIG_IsOK(res1)) {
28865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28866 }
28867 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28868 ecode2 = SWIG_AsVal_long(obj1, &val2);
28869 if (!SWIG_IsOK(ecode2)) {
28870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28871 }
28872 arg2 = static_cast< long >(val2);
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->SetFlags(arg2);
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_Py_Void();
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28887 PyObject *resultobj = 0;
28888 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28889 wxWindow *result = 0 ;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 PyObject *swig_obj[1] ;
28893
28894 if (!args) SWIG_fail;
28895 swig_obj[0] = args;
28896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28897 if (!SWIG_IsOK(res1)) {
28898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28899 }
28900 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 {
28908 resultobj = wxPyMake_wxObject(result, (bool)0);
28909 }
28910 return resultobj;
28911 fail:
28912 return NULL;
28913 }
28914
28915
28916 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28917 PyObject *resultobj = 0;
28918 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28919 wxWindow *arg2 = (wxWindow *) 0 ;
28920 void *argp1 = 0 ;
28921 int res1 = 0 ;
28922 void *argp2 = 0 ;
28923 int res2 = 0 ;
28924 PyObject * obj0 = 0 ;
28925 PyObject * obj1 = 0 ;
28926 char * kwnames[] = {
28927 (char *) "self",(char *) "win", NULL
28928 };
28929
28930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28932 if (!SWIG_IsOK(res1)) {
28933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28934 }
28935 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28937 if (!SWIG_IsOK(res2)) {
28938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28939 }
28940 arg2 = reinterpret_cast< wxWindow * >(argp2);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 (arg1)->SetCurrentFocus(arg2);
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_Py_Void();
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *obj;
28956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28957 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28958 return SWIG_Py_Void();
28959 }
28960
28961 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28962 return SWIG_Python_InitShadowInstance(args);
28963 }
28964
28965 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj = 0;
28967 wxWindow *arg1 = (wxWindow *) NULL ;
28968 wxWindowCreateEvent *result = 0 ;
28969 void *argp1 = 0 ;
28970 int res1 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 char * kwnames[] = {
28973 (char *) "win", NULL
28974 };
28975
28976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28977 if (obj0) {
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28981 }
28982 arg1 = reinterpret_cast< wxWindow * >(argp1);
28983 }
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29000 wxWindow *result = 0 ;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29010 }
29011 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 {
29019 resultobj = wxPyMake_wxObject(result, (bool)0);
29020 }
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *obj;
29029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29030 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29031 return SWIG_Py_Void();
29032 }
29033
29034 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29035 return SWIG_Python_InitShadowInstance(args);
29036 }
29037
29038 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj = 0;
29040 wxWindow *arg1 = (wxWindow *) NULL ;
29041 wxWindowDestroyEvent *result = 0 ;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject * obj0 = 0 ;
29045 char * kwnames[] = {
29046 (char *) "win", NULL
29047 };
29048
29049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29050 if (obj0) {
29051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29052 if (!SWIG_IsOK(res1)) {
29053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29054 }
29055 arg1 = reinterpret_cast< wxWindow * >(argp1);
29056 }
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29073 wxWindow *result = 0 ;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject *swig_obj[1] ;
29077
29078 if (!args) SWIG_fail;
29079 swig_obj[0] = args;
29080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29083 }
29084 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 {
29092 resultobj = wxPyMake_wxObject(result, (bool)0);
29093 }
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29101 PyObject *obj;
29102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29103 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29104 return SWIG_Py_Void();
29105 }
29106
29107 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 return SWIG_Python_InitShadowInstance(args);
29109 }
29110
29111 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj = 0;
29113 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29114 int arg2 = (int) 0 ;
29115 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29116 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29117 wxContextMenuEvent *result = 0 ;
29118 int val1 ;
29119 int ecode1 = 0 ;
29120 int val2 ;
29121 int ecode2 = 0 ;
29122 wxPoint temp3 ;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 PyObject * obj2 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "type",(char *) "winid",(char *) "pt", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29131 if (obj0) {
29132 ecode1 = SWIG_AsVal_int(obj0, &val1);
29133 if (!SWIG_IsOK(ecode1)) {
29134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29135 }
29136 arg1 = static_cast< wxEventType >(val1);
29137 }
29138 if (obj1) {
29139 ecode2 = SWIG_AsVal_int(obj1, &val2);
29140 if (!SWIG_IsOK(ecode2)) {
29141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29142 }
29143 arg2 = static_cast< int >(val2);
29144 }
29145 if (obj2) {
29146 {
29147 arg3 = &temp3;
29148 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29149 }
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29165 PyObject *resultobj = 0;
29166 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29167 wxPoint *result = 0 ;
29168 void *argp1 = 0 ;
29169 int res1 = 0 ;
29170 PyObject *swig_obj[1] ;
29171
29172 if (!args) SWIG_fail;
29173 swig_obj[0] = args;
29174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29177 }
29178 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 {
29182 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29183 result = (wxPoint *) &_result_ref;
29184 }
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj = 0;
29197 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29198 wxPoint *arg2 = 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 wxPoint temp2 ;
29202 PyObject * obj0 = 0 ;
29203 PyObject * obj1 = 0 ;
29204 char * kwnames[] = {
29205 (char *) "self",(char *) "pos", NULL
29206 };
29207
29208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29210 if (!SWIG_IsOK(res1)) {
29211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29212 }
29213 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29214 {
29215 arg2 = &temp2;
29216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29217 }
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->SetPosition((wxPoint const &)*arg2);
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_Py_Void();
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *obj;
29233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29234 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29235 return SWIG_Py_Void();
29236 }
29237
29238 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29239 return SWIG_Python_InitShadowInstance(args);
29240 }
29241
29242 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxIdleEvent *result = 0 ;
29245
29246 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 result = (wxIdleEvent *)new wxIdleEvent();
29250 wxPyEndAllowThreads(__tstate);
29251 if (PyErr_Occurred()) SWIG_fail;
29252 }
29253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj = 0;
29262 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29263 bool arg2 = (bool) true ;
29264 void *argp1 = 0 ;
29265 int res1 = 0 ;
29266 bool val2 ;
29267 int ecode2 = 0 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 char * kwnames[] = {
29271 (char *) "self",(char *) "needMore", NULL
29272 };
29273
29274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29276 if (!SWIG_IsOK(res1)) {
29277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29278 }
29279 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29280 if (obj1) {
29281 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29282 if (!SWIG_IsOK(ecode2)) {
29283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29284 }
29285 arg2 = static_cast< bool >(val2);
29286 }
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 (arg1)->RequestMore(arg2);
29290 wxPyEndAllowThreads(__tstate);
29291 if (PyErr_Occurred()) SWIG_fail;
29292 }
29293 resultobj = SWIG_Py_Void();
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29301 PyObject *resultobj = 0;
29302 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29303 bool result;
29304 void *argp1 = 0 ;
29305 int res1 = 0 ;
29306 PyObject *swig_obj[1] ;
29307
29308 if (!args) SWIG_fail;
29309 swig_obj[0] = args;
29310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29313 }
29314 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 {
29322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29323 }
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj = 0;
29332 wxIdleMode arg1 ;
29333 int val1 ;
29334 int ecode1 = 0 ;
29335 PyObject * obj0 = 0 ;
29336 char * kwnames[] = {
29337 (char *) "mode", NULL
29338 };
29339
29340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29341 ecode1 = SWIG_AsVal_int(obj0, &val1);
29342 if (!SWIG_IsOK(ecode1)) {
29343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29344 }
29345 arg1 = static_cast< wxIdleMode >(val1);
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 wxIdleEvent::SetMode(arg1);
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_Py_Void();
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29360 PyObject *resultobj = 0;
29361 wxIdleMode result;
29362
29363 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 result = (wxIdleMode)wxIdleEvent::GetMode();
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_From_int(static_cast< int >(result));
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxWindow *arg1 = (wxWindow *) 0 ;
29380 bool result;
29381 void *argp1 = 0 ;
29382 int res1 = 0 ;
29383 PyObject * obj0 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "win", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29392 }
29393 arg1 = reinterpret_cast< wxWindow * >(argp1);
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 result = (bool)wxIdleEvent::CanSend(arg1);
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 {
29401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29402 }
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *obj;
29411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29412 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29413 return SWIG_Py_Void();
29414 }
29415
29416 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 return SWIG_Python_InitShadowInstance(args);
29418 }
29419
29420 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = 0;
29422 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29423 int arg2 = (int) 0 ;
29424 wxClipboardTextEvent *result = 0 ;
29425 int val1 ;
29426 int ecode1 = 0 ;
29427 int val2 ;
29428 int ecode2 = 0 ;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "type",(char *) "winid", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29436 if (obj0) {
29437 ecode1 = SWIG_AsVal_int(obj0, &val1);
29438 if (!SWIG_IsOK(ecode1)) {
29439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29440 }
29441 arg1 = static_cast< wxEventType >(val1);
29442 }
29443 if (obj1) {
29444 ecode2 = SWIG_AsVal_int(obj1, &val2);
29445 if (!SWIG_IsOK(ecode2)) {
29446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29447 }
29448 arg2 = static_cast< int >(val2);
29449 }
29450 {
29451 PyThreadState* __tstate = wxPyBeginAllowThreads();
29452 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29453 wxPyEndAllowThreads(__tstate);
29454 if (PyErr_Occurred()) SWIG_fail;
29455 }
29456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29464 PyObject *obj;
29465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29466 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29467 return SWIG_Py_Void();
29468 }
29469
29470 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29471 return SWIG_Python_InitShadowInstance(args);
29472 }
29473
29474 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 int arg1 = (int) 0 ;
29477 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29478 wxPyEvent *result = 0 ;
29479 int val1 ;
29480 int ecode1 = 0 ;
29481 int val2 ;
29482 int ecode2 = 0 ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char * kwnames[] = {
29486 (char *) "winid",(char *) "eventType", NULL
29487 };
29488
29489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29490 if (obj0) {
29491 ecode1 = SWIG_AsVal_int(obj0, &val1);
29492 if (!SWIG_IsOK(ecode1)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29494 }
29495 arg1 = static_cast< int >(val1);
29496 }
29497 if (obj1) {
29498 ecode2 = SWIG_AsVal_int(obj1, &val2);
29499 if (!SWIG_IsOK(ecode2)) {
29500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29501 }
29502 arg2 = static_cast< wxEventType >(val2);
29503 }
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29518 PyObject *resultobj = 0;
29519 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29520 void *argp1 = 0 ;
29521 int res1 = 0 ;
29522 PyObject *swig_obj[1] ;
29523
29524 if (!args) SWIG_fail;
29525 swig_obj[0] = args;
29526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29527 if (!SWIG_IsOK(res1)) {
29528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29529 }
29530 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 delete arg1;
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_Py_Void();
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj = 0;
29547 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29548 PyObject *arg2 = (PyObject *) 0 ;
29549 void *argp1 = 0 ;
29550 int res1 = 0 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 char * kwnames[] = {
29554 (char *) "self",(char *) "self", NULL
29555 };
29556
29557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29559 if (!SWIG_IsOK(res1)) {
29560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29561 }
29562 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29563 arg2 = obj1;
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 (arg1)->SetSelf(arg2);
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 resultobj = SWIG_Py_Void();
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29578 PyObject *resultobj = 0;
29579 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29580 PyObject *result = 0 ;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 PyObject *swig_obj[1] ;
29584
29585 if (!args) SWIG_fail;
29586 swig_obj[0] = args;
29587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29588 if (!SWIG_IsOK(res1)) {
29589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29590 }
29591 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (PyObject *)(arg1)->GetSelf();
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = result;
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *obj;
29607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29608 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29609 return SWIG_Py_Void();
29610 }
29611
29612 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29613 return SWIG_Python_InitShadowInstance(args);
29614 }
29615
29616 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29617 PyObject *resultobj = 0;
29618 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29619 int arg2 = (int) 0 ;
29620 wxPyCommandEvent *result = 0 ;
29621 int val1 ;
29622 int ecode1 = 0 ;
29623 int val2 ;
29624 int ecode2 = 0 ;
29625 PyObject * obj0 = 0 ;
29626 PyObject * obj1 = 0 ;
29627 char * kwnames[] = {
29628 (char *) "eventType",(char *) "id", NULL
29629 };
29630
29631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29632 if (obj0) {
29633 ecode1 = SWIG_AsVal_int(obj0, &val1);
29634 if (!SWIG_IsOK(ecode1)) {
29635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29636 }
29637 arg1 = static_cast< wxEventType >(val1);
29638 }
29639 if (obj1) {
29640 ecode2 = SWIG_AsVal_int(obj1, &val2);
29641 if (!SWIG_IsOK(ecode2)) {
29642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29643 }
29644 arg2 = static_cast< int >(val2);
29645 }
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29660 PyObject *resultobj = 0;
29661 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29662 void *argp1 = 0 ;
29663 int res1 = 0 ;
29664 PyObject *swig_obj[1] ;
29665
29666 if (!args) SWIG_fail;
29667 swig_obj[0] = args;
29668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29669 if (!SWIG_IsOK(res1)) {
29670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29671 }
29672 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 delete arg1;
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 resultobj = SWIG_Py_Void();
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj = 0;
29689 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29690 PyObject *arg2 = (PyObject *) 0 ;
29691 void *argp1 = 0 ;
29692 int res1 = 0 ;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 char * kwnames[] = {
29696 (char *) "self",(char *) "self", NULL
29697 };
29698
29699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29701 if (!SWIG_IsOK(res1)) {
29702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29703 }
29704 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29705 arg2 = obj1;
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 (arg1)->SetSelf(arg2);
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = SWIG_Py_Void();
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29720 PyObject *resultobj = 0;
29721 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29722 PyObject *result = 0 ;
29723 void *argp1 = 0 ;
29724 int res1 = 0 ;
29725 PyObject *swig_obj[1] ;
29726
29727 if (!args) SWIG_fail;
29728 swig_obj[0] = args;
29729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29732 }
29733 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (PyObject *)(arg1)->GetSelf();
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 resultobj = result;
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29748 PyObject *obj;
29749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29750 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29751 return SWIG_Py_Void();
29752 }
29753
29754 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 return SWIG_Python_InitShadowInstance(args);
29756 }
29757
29758 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj = 0;
29760 wxWindow *arg1 = (wxWindow *) 0 ;
29761 wxDateTime *arg2 = 0 ;
29762 wxEventType arg3 ;
29763 wxDateEvent *result = 0 ;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 void *argp2 = 0 ;
29767 int res2 = 0 ;
29768 int val3 ;
29769 int ecode3 = 0 ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 char * kwnames[] = {
29774 (char *) "win",(char *) "dt",(char *) "type", NULL
29775 };
29776
29777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29779 if (!SWIG_IsOK(res1)) {
29780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29781 }
29782 arg1 = reinterpret_cast< wxWindow * >(argp1);
29783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29784 if (!SWIG_IsOK(res2)) {
29785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29786 }
29787 if (!argp2) {
29788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29789 }
29790 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29791 ecode3 = SWIG_AsVal_int(obj2, &val3);
29792 if (!SWIG_IsOK(ecode3)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29794 }
29795 arg3 = static_cast< wxEventType >(val3);
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29812 wxDateTime *result = 0 ;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 PyObject *swig_obj[1] ;
29816
29817 if (!args) SWIG_fail;
29818 swig_obj[0] = args;
29819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29822 }
29823 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 {
29827 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29828 result = (wxDateTime *) &_result_ref;
29829 }
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj = 0;
29842 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29843 wxDateTime *arg2 = 0 ;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 void *argp2 = 0 ;
29847 int res2 = 0 ;
29848 PyObject * obj0 = 0 ;
29849 PyObject * obj1 = 0 ;
29850 char * kwnames[] = {
29851 (char *) "self",(char *) "date", NULL
29852 };
29853
29854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29856 if (!SWIG_IsOK(res1)) {
29857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29858 }
29859 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29861 if (!SWIG_IsOK(res2)) {
29862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29863 }
29864 if (!argp2) {
29865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29866 }
29867 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->SetDate((wxDateTime const &)*arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_Py_Void();
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *obj;
29883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29884 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29885 return SWIG_Py_Void();
29886 }
29887
29888 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29889 return SWIG_Python_InitShadowInstance(args);
29890 }
29891
29892 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 wxPyApp *result = 0 ;
29895
29896 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (wxPyApp *)new_wxPyApp();
29900 wxPyEndAllowThreads(__tstate);
29901 if (PyErr_Occurred()) SWIG_fail;
29902 }
29903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29911 PyObject *resultobj = 0;
29912 wxPyApp *arg1 = (wxPyApp *) 0 ;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 PyObject *swig_obj[1] ;
29916
29917 if (!args) SWIG_fail;
29918 swig_obj[0] = args;
29919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29920 if (!SWIG_IsOK(res1)) {
29921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29922 }
29923 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 delete arg1;
29927
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 resultobj = SWIG_Py_Void();
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj = 0;
29940 wxPyApp *arg1 = (wxPyApp *) 0 ;
29941 PyObject *arg2 = (PyObject *) 0 ;
29942 PyObject *arg3 = (PyObject *) 0 ;
29943 bool arg4 = (bool) false ;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 bool val4 ;
29947 int ecode4 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 PyObject * obj2 = 0 ;
29951 PyObject * obj3 = 0 ;
29952 char * kwnames[] = {
29953 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29954 };
29955
29956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29960 }
29961 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29962 arg2 = obj1;
29963 arg3 = obj2;
29964 if (obj3) {
29965 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29966 if (!SWIG_IsOK(ecode4)) {
29967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29968 }
29969 arg4 = static_cast< bool >(val4);
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 resultobj = SWIG_Py_Void();
29978 return resultobj;
29979 fail:
29980 return NULL;
29981 }
29982
29983
29984 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29985 PyObject *resultobj = 0;
29986 wxPyApp *arg1 = (wxPyApp *) 0 ;
29987 wxString result;
29988 void *argp1 = 0 ;
29989 int res1 = 0 ;
29990 PyObject *swig_obj[1] ;
29991
29992 if (!args) SWIG_fail;
29993 swig_obj[0] = args;
29994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29995 if (!SWIG_IsOK(res1)) {
29996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
29997 }
29998 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 result = ((wxPyApp const *)arg1)->GetAppName();
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 {
30006 #if wxUSE_UNICODE
30007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30008 #else
30009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30010 #endif
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj = 0;
30020 wxPyApp *arg1 = (wxPyApp *) 0 ;
30021 wxString *arg2 = 0 ;
30022 void *argp1 = 0 ;
30023 int res1 = 0 ;
30024 bool temp2 = false ;
30025 PyObject * obj0 = 0 ;
30026 PyObject * obj1 = 0 ;
30027 char * kwnames[] = {
30028 (char *) "self",(char *) "name", NULL
30029 };
30030
30031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30033 if (!SWIG_IsOK(res1)) {
30034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30035 }
30036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30037 {
30038 arg2 = wxString_in_helper(obj1);
30039 if (arg2 == NULL) SWIG_fail;
30040 temp2 = true;
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 (arg1)->SetAppName((wxString const &)*arg2);
30045 wxPyEndAllowThreads(__tstate);
30046 if (PyErr_Occurred()) SWIG_fail;
30047 }
30048 resultobj = SWIG_Py_Void();
30049 {
30050 if (temp2)
30051 delete arg2;
30052 }
30053 return resultobj;
30054 fail:
30055 {
30056 if (temp2)
30057 delete arg2;
30058 }
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30064 PyObject *resultobj = 0;
30065 wxPyApp *arg1 = (wxPyApp *) 0 ;
30066 wxString result;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 PyObject *swig_obj[1] ;
30070
30071 if (!args) SWIG_fail;
30072 swig_obj[0] = args;
30073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30076 }
30077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30078 {
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = ((wxPyApp const *)arg1)->GetClassName();
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 {
30085 #if wxUSE_UNICODE
30086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30087 #else
30088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30089 #endif
30090 }
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj = 0;
30099 wxPyApp *arg1 = (wxPyApp *) 0 ;
30100 wxString *arg2 = 0 ;
30101 void *argp1 = 0 ;
30102 int res1 = 0 ;
30103 bool temp2 = false ;
30104 PyObject * obj0 = 0 ;
30105 PyObject * obj1 = 0 ;
30106 char * kwnames[] = {
30107 (char *) "self",(char *) "name", NULL
30108 };
30109
30110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30112 if (!SWIG_IsOK(res1)) {
30113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30114 }
30115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30116 {
30117 arg2 = wxString_in_helper(obj1);
30118 if (arg2 == NULL) SWIG_fail;
30119 temp2 = true;
30120 }
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 (arg1)->SetClassName((wxString const &)*arg2);
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_Py_Void();
30128 {
30129 if (temp2)
30130 delete arg2;
30131 }
30132 return resultobj;
30133 fail:
30134 {
30135 if (temp2)
30136 delete arg2;
30137 }
30138 return NULL;
30139 }
30140
30141
30142 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30143 PyObject *resultobj = 0;
30144 wxPyApp *arg1 = (wxPyApp *) 0 ;
30145 wxString *result = 0 ;
30146 void *argp1 = 0 ;
30147 int res1 = 0 ;
30148 PyObject *swig_obj[1] ;
30149
30150 if (!args) SWIG_fail;
30151 swig_obj[0] = args;
30152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30153 if (!SWIG_IsOK(res1)) {
30154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30155 }
30156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 {
30160 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30161 result = (wxString *) &_result_ref;
30162 }
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 {
30167 #if wxUSE_UNICODE
30168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30169 #else
30170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30171 #endif
30172 }
30173 return resultobj;
30174 fail:
30175 return NULL;
30176 }
30177
30178
30179 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30180 PyObject *resultobj = 0;
30181 wxPyApp *arg1 = (wxPyApp *) 0 ;
30182 wxString *arg2 = 0 ;
30183 void *argp1 = 0 ;
30184 int res1 = 0 ;
30185 bool temp2 = false ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 char * kwnames[] = {
30189 (char *) "self",(char *) "name", NULL
30190 };
30191
30192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30194 if (!SWIG_IsOK(res1)) {
30195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30196 }
30197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30198 {
30199 arg2 = wxString_in_helper(obj1);
30200 if (arg2 == NULL) SWIG_fail;
30201 temp2 = true;
30202 }
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 (arg1)->SetVendorName((wxString const &)*arg2);
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 resultobj = SWIG_Py_Void();
30210 {
30211 if (temp2)
30212 delete arg2;
30213 }
30214 return resultobj;
30215 fail:
30216 {
30217 if (temp2)
30218 delete arg2;
30219 }
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30225 PyObject *resultobj = 0;
30226 wxPyApp *arg1 = (wxPyApp *) 0 ;
30227 wxAppTraits *result = 0 ;
30228 void *argp1 = 0 ;
30229 int res1 = 0 ;
30230 PyObject *swig_obj[1] ;
30231
30232 if (!args) SWIG_fail;
30233 swig_obj[0] = args;
30234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30235 if (!SWIG_IsOK(res1)) {
30236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30237 }
30238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (wxAppTraits *)(arg1)->GetTraits();
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30253 PyObject *resultobj = 0;
30254 wxPyApp *arg1 = (wxPyApp *) 0 ;
30255 void *argp1 = 0 ;
30256 int res1 = 0 ;
30257 PyObject *swig_obj[1] ;
30258
30259 if (!args) SWIG_fail;
30260 swig_obj[0] = args;
30261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30262 if (!SWIG_IsOK(res1)) {
30263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30264 }
30265 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 (arg1)->ProcessPendingEvents();
30269 wxPyEndAllowThreads(__tstate);
30270 if (PyErr_Occurred()) SWIG_fail;
30271 }
30272 resultobj = SWIG_Py_Void();
30273 return resultobj;
30274 fail:
30275 return NULL;
30276 }
30277
30278
30279 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30280 PyObject *resultobj = 0;
30281 wxPyApp *arg1 = (wxPyApp *) 0 ;
30282 bool arg2 = (bool) false ;
30283 bool result;
30284 void *argp1 = 0 ;
30285 int res1 = 0 ;
30286 bool val2 ;
30287 int ecode2 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 PyObject * obj1 = 0 ;
30290 char * kwnames[] = {
30291 (char *) "self",(char *) "onlyIfNeeded", NULL
30292 };
30293
30294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30296 if (!SWIG_IsOK(res1)) {
30297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30298 }
30299 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30300 if (obj1) {
30301 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30302 if (!SWIG_IsOK(ecode2)) {
30303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30304 }
30305 arg2 = static_cast< bool >(val2);
30306 }
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = (bool)(arg1)->Yield(arg2);
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 {
30314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30315 }
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30323 PyObject *resultobj = 0;
30324 wxPyApp *arg1 = (wxPyApp *) 0 ;
30325 void *argp1 = 0 ;
30326 int res1 = 0 ;
30327 PyObject *swig_obj[1] ;
30328
30329 if (!args) SWIG_fail;
30330 swig_obj[0] = args;
30331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30332 if (!SWIG_IsOK(res1)) {
30333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30334 }
30335 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30336 {
30337 PyThreadState* __tstate = wxPyBeginAllowThreads();
30338 (arg1)->WakeUpIdle();
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 resultobj = SWIG_Py_Void();
30343 return resultobj;
30344 fail:
30345 return NULL;
30346 }
30347
30348
30349 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30350 PyObject *resultobj = 0;
30351 bool result;
30352
30353 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30354 {
30355 PyThreadState* __tstate = wxPyBeginAllowThreads();
30356 result = (bool)wxPyApp::IsMainLoopRunning();
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 {
30361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30362 }
30363 return resultobj;
30364 fail:
30365 return NULL;
30366 }
30367
30368
30369 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30370 PyObject *resultobj = 0;
30371 wxPyApp *arg1 = (wxPyApp *) 0 ;
30372 int result;
30373 void *argp1 = 0 ;
30374 int res1 = 0 ;
30375 PyObject *swig_obj[1] ;
30376
30377 if (!args) SWIG_fail;
30378 swig_obj[0] = args;
30379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30380 if (!SWIG_IsOK(res1)) {
30381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30382 }
30383 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = (int)(arg1)->MainLoop();
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 resultobj = SWIG_From_int(static_cast< int >(result));
30391 return resultobj;
30392 fail:
30393 return NULL;
30394 }
30395
30396
30397 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30398 PyObject *resultobj = 0;
30399 wxPyApp *arg1 = (wxPyApp *) 0 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 PyObject *swig_obj[1] ;
30403
30404 if (!args) SWIG_fail;
30405 swig_obj[0] = args;
30406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30407 if (!SWIG_IsOK(res1)) {
30408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30409 }
30410 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 (arg1)->Exit();
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30425 PyObject *resultobj = 0;
30426 wxPyApp *arg1 = (wxPyApp *) 0 ;
30427 wxLayoutDirection result;
30428 void *argp1 = 0 ;
30429 int res1 = 0 ;
30430 PyObject *swig_obj[1] ;
30431
30432 if (!args) SWIG_fail;
30433 swig_obj[0] = args;
30434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30435 if (!SWIG_IsOK(res1)) {
30436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30437 }
30438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30442 wxPyEndAllowThreads(__tstate);
30443 if (PyErr_Occurred()) SWIG_fail;
30444 }
30445 resultobj = SWIG_From_int(static_cast< int >(result));
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30453 PyObject *resultobj = 0;
30454 wxPyApp *arg1 = (wxPyApp *) 0 ;
30455 void *argp1 = 0 ;
30456 int res1 = 0 ;
30457 PyObject *swig_obj[1] ;
30458
30459 if (!args) SWIG_fail;
30460 swig_obj[0] = args;
30461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30464 }
30465 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 (arg1)->ExitMainLoop();
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 resultobj = SWIG_Py_Void();
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30480 PyObject *resultobj = 0;
30481 wxPyApp *arg1 = (wxPyApp *) 0 ;
30482 bool result;
30483 void *argp1 = 0 ;
30484 int res1 = 0 ;
30485 PyObject *swig_obj[1] ;
30486
30487 if (!args) SWIG_fail;
30488 swig_obj[0] = args;
30489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30490 if (!SWIG_IsOK(res1)) {
30491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30492 }
30493 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 result = (bool)(arg1)->Pending();
30497 wxPyEndAllowThreads(__tstate);
30498 if (PyErr_Occurred()) SWIG_fail;
30499 }
30500 {
30501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30502 }
30503 return resultobj;
30504 fail:
30505 return NULL;
30506 }
30507
30508
30509 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30510 PyObject *resultobj = 0;
30511 wxPyApp *arg1 = (wxPyApp *) 0 ;
30512 bool result;
30513 void *argp1 = 0 ;
30514 int res1 = 0 ;
30515 PyObject *swig_obj[1] ;
30516
30517 if (!args) SWIG_fail;
30518 swig_obj[0] = args;
30519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30520 if (!SWIG_IsOK(res1)) {
30521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30522 }
30523 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 result = (bool)(arg1)->Dispatch();
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 {
30531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30532 }
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30540 PyObject *resultobj = 0;
30541 wxPyApp *arg1 = (wxPyApp *) 0 ;
30542 bool result;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 PyObject *swig_obj[1] ;
30546
30547 if (!args) SWIG_fail;
30548 swig_obj[0] = args;
30549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30550 if (!SWIG_IsOK(res1)) {
30551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30552 }
30553 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 result = (bool)(arg1)->ProcessIdle();
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 {
30561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30562 }
30563 return resultobj;
30564 fail:
30565 return NULL;
30566 }
30567
30568
30569 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30570 PyObject *resultobj = 0;
30571 wxPyApp *arg1 = (wxPyApp *) 0 ;
30572 wxWindow *arg2 = (wxWindow *) 0 ;
30573 wxIdleEvent *arg3 = 0 ;
30574 bool result;
30575 void *argp1 = 0 ;
30576 int res1 = 0 ;
30577 void *argp2 = 0 ;
30578 int res2 = 0 ;
30579 void *argp3 = 0 ;
30580 int res3 = 0 ;
30581 PyObject * obj0 = 0 ;
30582 PyObject * obj1 = 0 ;
30583 PyObject * obj2 = 0 ;
30584 char * kwnames[] = {
30585 (char *) "self",(char *) "win",(char *) "event", NULL
30586 };
30587
30588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30590 if (!SWIG_IsOK(res1)) {
30591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30592 }
30593 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30595 if (!SWIG_IsOK(res2)) {
30596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30597 }
30598 arg2 = reinterpret_cast< wxWindow * >(argp2);
30599 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30600 if (!SWIG_IsOK(res3)) {
30601 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30602 }
30603 if (!argp3) {
30604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30605 }
30606 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30610 wxPyEndAllowThreads(__tstate);
30611 if (PyErr_Occurred()) SWIG_fail;
30612 }
30613 {
30614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30615 }
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30623 PyObject *resultobj = 0;
30624 wxPyApp *arg1 = (wxPyApp *) 0 ;
30625 bool result;
30626 void *argp1 = 0 ;
30627 int res1 = 0 ;
30628 PyObject *swig_obj[1] ;
30629
30630 if (!args) SWIG_fail;
30631 swig_obj[0] = args;
30632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30633 if (!SWIG_IsOK(res1)) {
30634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30635 }
30636 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 result = (bool)((wxPyApp const *)arg1)->IsActive();
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 {
30644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30645 }
30646 return resultobj;
30647 fail:
30648 return NULL;
30649 }
30650
30651
30652 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30653 PyObject *resultobj = 0;
30654 wxPyApp *arg1 = (wxPyApp *) 0 ;
30655 wxWindow *arg2 = (wxWindow *) 0 ;
30656 void *argp1 = 0 ;
30657 int res1 = 0 ;
30658 void *argp2 = 0 ;
30659 int res2 = 0 ;
30660 PyObject * obj0 = 0 ;
30661 PyObject * obj1 = 0 ;
30662 char * kwnames[] = {
30663 (char *) "self",(char *) "win", NULL
30664 };
30665
30666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30670 }
30671 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30673 if (!SWIG_IsOK(res2)) {
30674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30675 }
30676 arg2 = reinterpret_cast< wxWindow * >(argp2);
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 (arg1)->SetTopWindow(arg2);
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 resultobj = SWIG_Py_Void();
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30691 PyObject *resultobj = 0;
30692 wxPyApp *arg1 = (wxPyApp *) 0 ;
30693 wxWindow *result = 0 ;
30694 void *argp1 = 0 ;
30695 int res1 = 0 ;
30696 PyObject *swig_obj[1] ;
30697
30698 if (!args) SWIG_fail;
30699 swig_obj[0] = args;
30700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30701 if (!SWIG_IsOK(res1)) {
30702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30703 }
30704 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 {
30712 resultobj = wxPyMake_wxObject(result, (bool)0);
30713 }
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj = 0;
30722 wxPyApp *arg1 = (wxPyApp *) 0 ;
30723 bool arg2 ;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 bool val2 ;
30727 int ecode2 = 0 ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 char * kwnames[] = {
30731 (char *) "self",(char *) "flag", NULL
30732 };
30733
30734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30736 if (!SWIG_IsOK(res1)) {
30737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30738 }
30739 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30740 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30741 if (!SWIG_IsOK(ecode2)) {
30742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30743 }
30744 arg2 = static_cast< bool >(val2);
30745 {
30746 PyThreadState* __tstate = wxPyBeginAllowThreads();
30747 (arg1)->SetExitOnFrameDelete(arg2);
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 resultobj = SWIG_Py_Void();
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30759 PyObject *resultobj = 0;
30760 wxPyApp *arg1 = (wxPyApp *) 0 ;
30761 bool result;
30762 void *argp1 = 0 ;
30763 int res1 = 0 ;
30764 PyObject *swig_obj[1] ;
30765
30766 if (!args) SWIG_fail;
30767 swig_obj[0] = args;
30768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30769 if (!SWIG_IsOK(res1)) {
30770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30771 }
30772 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30776 wxPyEndAllowThreads(__tstate);
30777 if (PyErr_Occurred()) SWIG_fail;
30778 }
30779 {
30780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30781 }
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 wxPyApp *arg1 = (wxPyApp *) 0 ;
30791 bool arg2 ;
30792 bool arg3 = (bool) false ;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 bool val2 ;
30796 int ecode2 = 0 ;
30797 bool val3 ;
30798 int ecode3 = 0 ;
30799 PyObject * obj0 = 0 ;
30800 PyObject * obj1 = 0 ;
30801 PyObject * obj2 = 0 ;
30802 char * kwnames[] = {
30803 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30804 };
30805
30806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30808 if (!SWIG_IsOK(res1)) {
30809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30810 }
30811 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30813 if (!SWIG_IsOK(ecode2)) {
30814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30815 }
30816 arg2 = static_cast< bool >(val2);
30817 if (obj2) {
30818 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30819 if (!SWIG_IsOK(ecode3)) {
30820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30821 }
30822 arg3 = static_cast< bool >(val3);
30823 }
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 (arg1)->SetUseBestVisual(arg2,arg3);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_Py_Void();
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30838 PyObject *resultobj = 0;
30839 wxPyApp *arg1 = (wxPyApp *) 0 ;
30840 bool result;
30841 void *argp1 = 0 ;
30842 int res1 = 0 ;
30843 PyObject *swig_obj[1] ;
30844
30845 if (!args) SWIG_fail;
30846 swig_obj[0] = args;
30847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30848 if (!SWIG_IsOK(res1)) {
30849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30850 }
30851 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30852 {
30853 PyThreadState* __tstate = wxPyBeginAllowThreads();
30854 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 {
30859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj = 0;
30869 wxPyApp *arg1 = (wxPyApp *) 0 ;
30870 int arg2 ;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 int val2 ;
30874 int ecode2 = 0 ;
30875 PyObject * obj0 = 0 ;
30876 PyObject * obj1 = 0 ;
30877 char * kwnames[] = {
30878 (char *) "self",(char *) "mode", NULL
30879 };
30880
30881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30883 if (!SWIG_IsOK(res1)) {
30884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30885 }
30886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30887 ecode2 = SWIG_AsVal_int(obj1, &val2);
30888 if (!SWIG_IsOK(ecode2)) {
30889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30890 }
30891 arg2 = static_cast< int >(val2);
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 (arg1)->SetPrintMode(arg2);
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = SWIG_Py_Void();
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30906 PyObject *resultobj = 0;
30907 wxPyApp *arg1 = (wxPyApp *) 0 ;
30908 int result;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 PyObject *swig_obj[1] ;
30912
30913 if (!args) SWIG_fail;
30914 swig_obj[0] = args;
30915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30916 if (!SWIG_IsOK(res1)) {
30917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30918 }
30919 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 resultobj = SWIG_From_int(static_cast< int >(result));
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj = 0;
30935 wxPyApp *arg1 = (wxPyApp *) 0 ;
30936 int arg2 ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 int val2 ;
30940 int ecode2 = 0 ;
30941 PyObject * obj0 = 0 ;
30942 PyObject * obj1 = 0 ;
30943 char * kwnames[] = {
30944 (char *) "self",(char *) "mode", NULL
30945 };
30946
30947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30949 if (!SWIG_IsOK(res1)) {
30950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30951 }
30952 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30953 ecode2 = SWIG_AsVal_int(obj1, &val2);
30954 if (!SWIG_IsOK(ecode2)) {
30955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30956 }
30957 arg2 = static_cast< int >(val2);
30958 {
30959 PyThreadState* __tstate = wxPyBeginAllowThreads();
30960 (arg1)->SetAssertMode(arg2);
30961 wxPyEndAllowThreads(__tstate);
30962 if (PyErr_Occurred()) SWIG_fail;
30963 }
30964 resultobj = SWIG_Py_Void();
30965 return resultobj;
30966 fail:
30967 return NULL;
30968 }
30969
30970
30971 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30972 PyObject *resultobj = 0;
30973 wxPyApp *arg1 = (wxPyApp *) 0 ;
30974 int result;
30975 void *argp1 = 0 ;
30976 int res1 = 0 ;
30977 PyObject *swig_obj[1] ;
30978
30979 if (!args) SWIG_fail;
30980 swig_obj[0] = args;
30981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30982 if (!SWIG_IsOK(res1)) {
30983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30984 }
30985 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 result = (int)(arg1)->GetAssertMode();
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 resultobj = SWIG_From_int(static_cast< int >(result));
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31000 PyObject *resultobj = 0;
31001 bool result;
31002
31003 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 {
31011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31012 }
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31020 PyObject *resultobj = 0;
31021 long result;
31022
31023 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31024 {
31025 PyThreadState* __tstate = wxPyBeginAllowThreads();
31026 result = (long)wxPyApp::GetMacAboutMenuItemId();
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 resultobj = SWIG_From_long(static_cast< long >(result));
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31038 PyObject *resultobj = 0;
31039 long result;
31040
31041 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 resultobj = SWIG_From_long(static_cast< long >(result));
31049 return resultobj;
31050 fail:
31051 return NULL;
31052 }
31053
31054
31055 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31056 PyObject *resultobj = 0;
31057 long result;
31058
31059 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 result = (long)wxPyApp::GetMacExitMenuItemId();
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 resultobj = SWIG_From_long(static_cast< long >(result));
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074 PyObject *resultobj = 0;
31075 wxString result;
31076
31077 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = wxPyApp::GetMacHelpMenuTitleName();
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 {
31085 #if wxUSE_UNICODE
31086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31087 #else
31088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31089 #endif
31090 }
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj = 0;
31099 bool arg1 ;
31100 bool val1 ;
31101 int ecode1 = 0 ;
31102 PyObject * obj0 = 0 ;
31103 char * kwnames[] = {
31104 (char *) "val", NULL
31105 };
31106
31107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31108 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31109 if (!SWIG_IsOK(ecode1)) {
31110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31111 }
31112 arg1 = static_cast< bool >(val1);
31113 {
31114 PyThreadState* __tstate = wxPyBeginAllowThreads();
31115 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 resultobj = SWIG_Py_Void();
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj = 0;
31128 long arg1 ;
31129 long val1 ;
31130 int ecode1 = 0 ;
31131 PyObject * obj0 = 0 ;
31132 char * kwnames[] = {
31133 (char *) "val", NULL
31134 };
31135
31136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31137 ecode1 = SWIG_AsVal_long(obj0, &val1);
31138 if (!SWIG_IsOK(ecode1)) {
31139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31140 }
31141 arg1 = static_cast< long >(val1);
31142 {
31143 PyThreadState* __tstate = wxPyBeginAllowThreads();
31144 wxPyApp::SetMacAboutMenuItemId(arg1);
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 resultobj = SWIG_Py_Void();
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj = 0;
31157 long arg1 ;
31158 long val1 ;
31159 int ecode1 = 0 ;
31160 PyObject * obj0 = 0 ;
31161 char * kwnames[] = {
31162 (char *) "val", NULL
31163 };
31164
31165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31166 ecode1 = SWIG_AsVal_long(obj0, &val1);
31167 if (!SWIG_IsOK(ecode1)) {
31168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31169 }
31170 arg1 = static_cast< long >(val1);
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 resultobj = SWIG_Py_Void();
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj = 0;
31186 long arg1 ;
31187 long val1 ;
31188 int ecode1 = 0 ;
31189 PyObject * obj0 = 0 ;
31190 char * kwnames[] = {
31191 (char *) "val", NULL
31192 };
31193
31194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31195 ecode1 = SWIG_AsVal_long(obj0, &val1);
31196 if (!SWIG_IsOK(ecode1)) {
31197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31198 }
31199 arg1 = static_cast< long >(val1);
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 wxPyApp::SetMacExitMenuItemId(arg1);
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_Py_Void();
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj = 0;
31215 wxString *arg1 = 0 ;
31216 bool temp1 = false ;
31217 PyObject * obj0 = 0 ;
31218 char * kwnames[] = {
31219 (char *) "val", NULL
31220 };
31221
31222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31223 {
31224 arg1 = wxString_in_helper(obj0);
31225 if (arg1 == NULL) SWIG_fail;
31226 temp1 = true;
31227 }
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 resultobj = SWIG_Py_Void();
31235 {
31236 if (temp1)
31237 delete arg1;
31238 }
31239 return resultobj;
31240 fail:
31241 {
31242 if (temp1)
31243 delete arg1;
31244 }
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 wxPyApp *arg1 = (wxPyApp *) 0 ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 PyObject *swig_obj[1] ;
31255
31256 if (!args) SWIG_fail;
31257 swig_obj[0] = args;
31258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31259 if (!SWIG_IsOK(res1)) {
31260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31261 }
31262 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 (arg1)->_BootstrapApp();
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 resultobj = SWIG_Py_Void();
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31277 PyObject *resultobj = 0;
31278 int result;
31279
31280 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 result = (int)wxPyApp::GetComCtl32Version();
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 resultobj = SWIG_From_int(static_cast< int >(result));
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31295 PyObject *resultobj = 0;
31296 bool result;
31297
31298 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31299 {
31300 PyThreadState* __tstate = wxPyBeginAllowThreads();
31301 result = (bool)wxPyApp_IsDisplayAvailable();
31302 wxPyEndAllowThreads(__tstate);
31303 if (PyErr_Occurred()) SWIG_fail;
31304 }
31305 {
31306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31307 }
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31315 PyObject *obj;
31316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31318 return SWIG_Py_Void();
31319 }
31320
31321 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31322 return SWIG_Python_InitShadowInstance(args);
31323 }
31324
31325 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31326 PyObject *resultobj = 0;
31327
31328 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 wxExit();
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 resultobj = SWIG_Py_Void();
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31343 PyObject *resultobj = 0;
31344 bool result;
31345
31346 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = (bool)wxYield();
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 {
31354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31355 }
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31363 PyObject *resultobj = 0;
31364 bool result;
31365
31366 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31367 {
31368 PyThreadState* __tstate = wxPyBeginAllowThreads();
31369 result = (bool)wxYieldIfNeeded();
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 {
31374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31375 }
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj = 0;
31384 wxWindow *arg1 = (wxWindow *) NULL ;
31385 bool arg2 = (bool) false ;
31386 bool result;
31387 void *argp1 = 0 ;
31388 int res1 = 0 ;
31389 bool val2 ;
31390 int ecode2 = 0 ;
31391 PyObject * obj0 = 0 ;
31392 PyObject * obj1 = 0 ;
31393 char * kwnames[] = {
31394 (char *) "win",(char *) "onlyIfNeeded", NULL
31395 };
31396
31397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31398 if (obj0) {
31399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31400 if (!SWIG_IsOK(res1)) {
31401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31402 }
31403 arg1 = reinterpret_cast< wxWindow * >(argp1);
31404 }
31405 if (obj1) {
31406 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31407 if (!SWIG_IsOK(ecode2)) {
31408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31409 }
31410 arg2 = static_cast< bool >(val2);
31411 }
31412 {
31413 PyThreadState* __tstate = wxPyBeginAllowThreads();
31414 result = (bool)wxSafeYield(arg1,arg2);
31415 wxPyEndAllowThreads(__tstate);
31416 if (PyErr_Occurred()) SWIG_fail;
31417 }
31418 {
31419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31420 }
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31428 PyObject *resultobj = 0;
31429
31430 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 wxWakeUpIdle();
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 resultobj = SWIG_Py_Void();
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31445 PyObject *resultobj = 0;
31446 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31447 wxEvent *arg2 = 0 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 void *argp2 = 0 ;
31451 int res2 = 0 ;
31452 PyObject * obj0 = 0 ;
31453 PyObject * obj1 = 0 ;
31454 char * kwnames[] = {
31455 (char *) "dest",(char *) "event", NULL
31456 };
31457
31458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31460 if (!SWIG_IsOK(res1)) {
31461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31462 }
31463 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31465 if (!SWIG_IsOK(res2)) {
31466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31467 }
31468 if (!argp2) {
31469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31470 }
31471 arg2 = reinterpret_cast< wxEvent * >(argp2);
31472 {
31473 PyThreadState* __tstate = wxPyBeginAllowThreads();
31474 wxPostEvent(arg1,*arg2);
31475 wxPyEndAllowThreads(__tstate);
31476 if (PyErr_Occurred()) SWIG_fail;
31477 }
31478 resultobj = SWIG_Py_Void();
31479 return resultobj;
31480 fail:
31481 return NULL;
31482 }
31483
31484
31485 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31486 PyObject *resultobj = 0;
31487
31488 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31489 {
31490 PyThreadState* __tstate = wxPyBeginAllowThreads();
31491 wxApp_CleanUp();
31492 wxPyEndAllowThreads(__tstate);
31493 if (PyErr_Occurred()) SWIG_fail;
31494 }
31495 resultobj = SWIG_Py_Void();
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31503 PyObject *resultobj = 0;
31504 wxPyApp *result = 0 ;
31505
31506 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (wxPyApp *)wxPyGetApp();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 {
31514 resultobj = wxPyMake_wxObject(result, 0);
31515 }
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31523 PyObject *resultobj = 0;
31524 char *arg1 = (char *) 0 ;
31525 int res1 ;
31526 char *buf1 = 0 ;
31527 int alloc1 = 0 ;
31528 PyObject * obj0 = 0 ;
31529 char * kwnames[] = {
31530 (char *) "encoding", NULL
31531 };
31532
31533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31534 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31535 if (!SWIG_IsOK(res1)) {
31536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31537 }
31538 arg1 = buf1;
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 wxSetDefaultPyEncoding((char const *)arg1);
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 resultobj = SWIG_Py_Void();
31546 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31547 return resultobj;
31548 fail:
31549 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 PyObject *resultobj = 0;
31556 char *result = 0 ;
31557
31558 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = (char *)wxGetDefaultPyEncoding();
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_FromCharPtr(result);
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31573 PyObject *resultobj = 0;
31574 wxEventLoop *result = 0 ;
31575
31576 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 result = (wxEventLoop *)new wxEventLoop();
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31591 PyObject *resultobj = 0;
31592 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31593 void *argp1 = 0 ;
31594 int res1 = 0 ;
31595 PyObject *swig_obj[1] ;
31596
31597 if (!args) SWIG_fail;
31598 swig_obj[0] = args;
31599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31600 if (!SWIG_IsOK(res1)) {
31601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31602 }
31603 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 delete arg1;
31607
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 resultobj = SWIG_Py_Void();
31612 return resultobj;
31613 fail:
31614 return NULL;
31615 }
31616
31617
31618 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31619 PyObject *resultobj = 0;
31620 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31621 int result;
31622 void *argp1 = 0 ;
31623 int res1 = 0 ;
31624 PyObject *swig_obj[1] ;
31625
31626 if (!args) SWIG_fail;
31627 swig_obj[0] = args;
31628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31629 if (!SWIG_IsOK(res1)) {
31630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31631 }
31632 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 result = (int)(arg1)->Run();
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 resultobj = SWIG_From_int(static_cast< int >(result));
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31647 PyObject *resultobj = 0;
31648 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31649 int arg2 = (int) 0 ;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 int val2 ;
31653 int ecode2 = 0 ;
31654 PyObject * obj0 = 0 ;
31655 PyObject * obj1 = 0 ;
31656 char * kwnames[] = {
31657 (char *) "self",(char *) "rc", NULL
31658 };
31659
31660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31662 if (!SWIG_IsOK(res1)) {
31663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31664 }
31665 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31666 if (obj1) {
31667 ecode2 = SWIG_AsVal_int(obj1, &val2);
31668 if (!SWIG_IsOK(ecode2)) {
31669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31670 }
31671 arg2 = static_cast< int >(val2);
31672 }
31673 {
31674 PyThreadState* __tstate = wxPyBeginAllowThreads();
31675 (arg1)->Exit(arg2);
31676 wxPyEndAllowThreads(__tstate);
31677 if (PyErr_Occurred()) SWIG_fail;
31678 }
31679 resultobj = SWIG_Py_Void();
31680 return resultobj;
31681 fail:
31682 return NULL;
31683 }
31684
31685
31686 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31687 PyObject *resultobj = 0;
31688 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31689 bool result;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 PyObject *swig_obj[1] ;
31693
31694 if (!args) SWIG_fail;
31695 swig_obj[0] = args;
31696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31697 if (!SWIG_IsOK(res1)) {
31698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31699 }
31700 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31701 {
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 result = (bool)((wxEventLoop const *)arg1)->Pending();
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31719 bool result;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 PyObject *swig_obj[1] ;
31723
31724 if (!args) SWIG_fail;
31725 swig_obj[0] = args;
31726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31727 if (!SWIG_IsOK(res1)) {
31728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31729 }
31730 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = (bool)(arg1)->Dispatch();
31734 wxPyEndAllowThreads(__tstate);
31735 if (PyErr_Occurred()) SWIG_fail;
31736 }
31737 {
31738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31739 }
31740 return resultobj;
31741 fail:
31742 return NULL;
31743 }
31744
31745
31746 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31747 PyObject *resultobj = 0;
31748 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31749 bool result;
31750 void *argp1 = 0 ;
31751 int res1 = 0 ;
31752 PyObject *swig_obj[1] ;
31753
31754 if (!args) SWIG_fail;
31755 swig_obj[0] = args;
31756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31757 if (!SWIG_IsOK(res1)) {
31758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31759 }
31760 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31761 {
31762 PyThreadState* __tstate = wxPyBeginAllowThreads();
31763 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31764 wxPyEndAllowThreads(__tstate);
31765 if (PyErr_Occurred()) SWIG_fail;
31766 }
31767 {
31768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31769 }
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31777 PyObject *resultobj = 0;
31778 wxEventLoop *result = 0 ;
31779
31780 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 result = (wxEventLoop *)wxEventLoop::GetActive();
31784 wxPyEndAllowThreads(__tstate);
31785 if (PyErr_Occurred()) SWIG_fail;
31786 }
31787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31788 return resultobj;
31789 fail:
31790 return NULL;
31791 }
31792
31793
31794 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31795 PyObject *resultobj = 0;
31796 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 PyObject * obj0 = 0 ;
31800 char * kwnames[] = {
31801 (char *) "loop", NULL
31802 };
31803
31804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31808 }
31809 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 wxEventLoop::SetActive(arg1);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_Py_Void();
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *obj;
31825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31826 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31827 return SWIG_Py_Void();
31828 }
31829
31830 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 return SWIG_Python_InitShadowInstance(args);
31832 }
31833
31834 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31835 PyObject *resultobj = 0;
31836 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31837 wxEventLoopActivator *result = 0 ;
31838 void *argp1 = 0 ;
31839 int res1 = 0 ;
31840 PyObject * obj0 = 0 ;
31841 char * kwnames[] = {
31842 (char *) "evtLoop", NULL
31843 };
31844
31845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31847 if (!SWIG_IsOK(res1)) {
31848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31849 }
31850 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31854 wxPyEndAllowThreads(__tstate);
31855 if (PyErr_Occurred()) SWIG_fail;
31856 }
31857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31865 PyObject *resultobj = 0;
31866 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 PyObject *swig_obj[1] ;
31870
31871 if (!args) SWIG_fail;
31872 swig_obj[0] = args;
31873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31874 if (!SWIG_IsOK(res1)) {
31875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31876 }
31877 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31878 {
31879 PyThreadState* __tstate = wxPyBeginAllowThreads();
31880 delete arg1;
31881
31882 wxPyEndAllowThreads(__tstate);
31883 if (PyErr_Occurred()) SWIG_fail;
31884 }
31885 resultobj = SWIG_Py_Void();
31886 return resultobj;
31887 fail:
31888 return NULL;
31889 }
31890
31891
31892 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31893 PyObject *obj;
31894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31895 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31896 return SWIG_Py_Void();
31897 }
31898
31899 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31900 return SWIG_Python_InitShadowInstance(args);
31901 }
31902
31903 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31904 PyObject *resultobj = 0;
31905 int arg1 = (int) 0 ;
31906 int arg2 = (int) 0 ;
31907 int arg3 = (int) 0 ;
31908 wxAcceleratorEntry *result = 0 ;
31909 int val1 ;
31910 int ecode1 = 0 ;
31911 int val2 ;
31912 int ecode2 = 0 ;
31913 int val3 ;
31914 int ecode3 = 0 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 PyObject * obj2 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31923 if (obj0) {
31924 ecode1 = SWIG_AsVal_int(obj0, &val1);
31925 if (!SWIG_IsOK(ecode1)) {
31926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31927 }
31928 arg1 = static_cast< int >(val1);
31929 }
31930 if (obj1) {
31931 ecode2 = SWIG_AsVal_int(obj1, &val2);
31932 if (!SWIG_IsOK(ecode2)) {
31933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31934 }
31935 arg2 = static_cast< int >(val2);
31936 }
31937 if (obj2) {
31938 ecode3 = SWIG_AsVal_int(obj2, &val3);
31939 if (!SWIG_IsOK(ecode3)) {
31940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31941 }
31942 arg3 = static_cast< int >(val3);
31943 }
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31947 wxPyEndAllowThreads(__tstate);
31948 if (PyErr_Occurred()) SWIG_fail;
31949 }
31950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31951 return resultobj;
31952 fail:
31953 return NULL;
31954 }
31955
31956
31957 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31958 PyObject *resultobj = 0;
31959 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31960 void *argp1 = 0 ;
31961 int res1 = 0 ;
31962 PyObject *swig_obj[1] ;
31963
31964 if (!args) SWIG_fail;
31965 swig_obj[0] = args;
31966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31967 if (!SWIG_IsOK(res1)) {
31968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31969 }
31970 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31971 {
31972 PyThreadState* __tstate = wxPyBeginAllowThreads();
31973 delete arg1;
31974
31975 wxPyEndAllowThreads(__tstate);
31976 if (PyErr_Occurred()) SWIG_fail;
31977 }
31978 resultobj = SWIG_Py_Void();
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31986 PyObject *resultobj = 0;
31987 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31988 int arg2 ;
31989 int arg3 ;
31990 int arg4 ;
31991 void *argp1 = 0 ;
31992 int res1 = 0 ;
31993 int val2 ;
31994 int ecode2 = 0 ;
31995 int val3 ;
31996 int ecode3 = 0 ;
31997 int val4 ;
31998 int ecode4 = 0 ;
31999 PyObject * obj0 = 0 ;
32000 PyObject * obj1 = 0 ;
32001 PyObject * obj2 = 0 ;
32002 PyObject * obj3 = 0 ;
32003 char * kwnames[] = {
32004 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32005 };
32006
32007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32009 if (!SWIG_IsOK(res1)) {
32010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32011 }
32012 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32013 ecode2 = SWIG_AsVal_int(obj1, &val2);
32014 if (!SWIG_IsOK(ecode2)) {
32015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32016 }
32017 arg2 = static_cast< int >(val2);
32018 ecode3 = SWIG_AsVal_int(obj2, &val3);
32019 if (!SWIG_IsOK(ecode3)) {
32020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32021 }
32022 arg3 = static_cast< int >(val3);
32023 ecode4 = SWIG_AsVal_int(obj3, &val4);
32024 if (!SWIG_IsOK(ecode4)) {
32025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32026 }
32027 arg4 = static_cast< int >(val4);
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 (arg1)->Set(arg2,arg3,arg4);
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = SWIG_Py_Void();
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32042 PyObject *resultobj = 0;
32043 wxString *arg1 = 0 ;
32044 wxAcceleratorEntry *result = 0 ;
32045 bool temp1 = false ;
32046 PyObject * obj0 = 0 ;
32047 char * kwnames[] = {
32048 (char *) "str", NULL
32049 };
32050
32051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32052 {
32053 arg1 = wxString_in_helper(obj0);
32054 if (arg1 == NULL) SWIG_fail;
32055 temp1 = true;
32056 }
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32060 wxPyEndAllowThreads(__tstate);
32061 if (PyErr_Occurred()) SWIG_fail;
32062 }
32063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32064 {
32065 if (temp1)
32066 delete arg1;
32067 }
32068 return resultobj;
32069 fail:
32070 {
32071 if (temp1)
32072 delete arg1;
32073 }
32074 return NULL;
32075 }
32076
32077
32078 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32079 PyObject *resultobj = 0;
32080 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32081 int result;
32082 void *argp1 = 0 ;
32083 int res1 = 0 ;
32084 PyObject *swig_obj[1] ;
32085
32086 if (!args) SWIG_fail;
32087 swig_obj[0] = args;
32088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32091 }
32092 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 result = (int)(arg1)->GetFlags();
32096 wxPyEndAllowThreads(__tstate);
32097 if (PyErr_Occurred()) SWIG_fail;
32098 }
32099 resultobj = SWIG_From_int(static_cast< int >(result));
32100 return resultobj;
32101 fail:
32102 return NULL;
32103 }
32104
32105
32106 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32107 PyObject *resultobj = 0;
32108 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32109 int result;
32110 void *argp1 = 0 ;
32111 int res1 = 0 ;
32112 PyObject *swig_obj[1] ;
32113
32114 if (!args) SWIG_fail;
32115 swig_obj[0] = args;
32116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32117 if (!SWIG_IsOK(res1)) {
32118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32119 }
32120 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (int)(arg1)->GetKeyCode();
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 resultobj = SWIG_From_int(static_cast< int >(result));
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32135 PyObject *resultobj = 0;
32136 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32137 int result;
32138 void *argp1 = 0 ;
32139 int res1 = 0 ;
32140 PyObject *swig_obj[1] ;
32141
32142 if (!args) SWIG_fail;
32143 swig_obj[0] = args;
32144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32145 if (!SWIG_IsOK(res1)) {
32146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32147 }
32148 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32149 {
32150 PyThreadState* __tstate = wxPyBeginAllowThreads();
32151 result = (int)(arg1)->GetCommand();
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 resultobj = SWIG_From_int(static_cast< int >(result));
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32163 PyObject *resultobj = 0;
32164 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32165 bool result;
32166 void *argp1 = 0 ;
32167 int res1 = 0 ;
32168 PyObject *swig_obj[1] ;
32169
32170 if (!args) SWIG_fail;
32171 swig_obj[0] = args;
32172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32173 if (!SWIG_IsOK(res1)) {
32174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32175 }
32176 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 {
32184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32185 }
32186 return resultobj;
32187 fail:
32188 return NULL;
32189 }
32190
32191
32192 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32193 PyObject *resultobj = 0;
32194 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32195 wxString result;
32196 void *argp1 = 0 ;
32197 int res1 = 0 ;
32198 PyObject *swig_obj[1] ;
32199
32200 if (!args) SWIG_fail;
32201 swig_obj[0] = args;
32202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32203 if (!SWIG_IsOK(res1)) {
32204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32205 }
32206 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32207 {
32208 PyThreadState* __tstate = wxPyBeginAllowThreads();
32209 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32210 wxPyEndAllowThreads(__tstate);
32211 if (PyErr_Occurred()) SWIG_fail;
32212 }
32213 {
32214 #if wxUSE_UNICODE
32215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32216 #else
32217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32218 #endif
32219 }
32220 return resultobj;
32221 fail:
32222 return NULL;
32223 }
32224
32225
32226 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32227 PyObject *resultobj = 0;
32228 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32229 wxString *arg2 = 0 ;
32230 bool result;
32231 void *argp1 = 0 ;
32232 int res1 = 0 ;
32233 bool temp2 = false ;
32234 PyObject * obj0 = 0 ;
32235 PyObject * obj1 = 0 ;
32236 char * kwnames[] = {
32237 (char *) "self",(char *) "str", NULL
32238 };
32239
32240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32244 }
32245 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32246 {
32247 arg2 = wxString_in_helper(obj1);
32248 if (arg2 == NULL) SWIG_fail;
32249 temp2 = true;
32250 }
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32259 }
32260 {
32261 if (temp2)
32262 delete arg2;
32263 }
32264 return resultobj;
32265 fail:
32266 {
32267 if (temp2)
32268 delete arg2;
32269 }
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32275 PyObject *obj;
32276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32277 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32278 return SWIG_Py_Void();
32279 }
32280
32281 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32282 return SWIG_Python_InitShadowInstance(args);
32283 }
32284
32285 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32286 PyObject *resultobj = 0;
32287 int arg1 ;
32288 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32289 wxAcceleratorTable *result = 0 ;
32290 PyObject * obj0 = 0 ;
32291 char * kwnames[] = {
32292 (char *) "n", NULL
32293 };
32294
32295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32296 {
32297 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32298 if (arg2) arg1 = PyList_Size(obj0);
32299 else arg1 = 0;
32300 }
32301 {
32302 PyThreadState* __tstate = wxPyBeginAllowThreads();
32303 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32304 wxPyEndAllowThreads(__tstate);
32305 if (PyErr_Occurred()) SWIG_fail;
32306 }
32307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32308 return resultobj;
32309 fail:
32310 return NULL;
32311 }
32312
32313
32314 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32315 PyObject *resultobj = 0;
32316 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32317 void *argp1 = 0 ;
32318 int res1 = 0 ;
32319 PyObject *swig_obj[1] ;
32320
32321 if (!args) SWIG_fail;
32322 swig_obj[0] = args;
32323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32324 if (!SWIG_IsOK(res1)) {
32325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32326 }
32327 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 delete arg1;
32331
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 resultobj = SWIG_Py_Void();
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32343 PyObject *resultobj = 0;
32344 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32345 bool result;
32346 void *argp1 = 0 ;
32347 int res1 = 0 ;
32348 PyObject *swig_obj[1] ;
32349
32350 if (!args) SWIG_fail;
32351 swig_obj[0] = args;
32352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32353 if (!SWIG_IsOK(res1)) {
32354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32355 }
32356 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32357 {
32358 PyThreadState* __tstate = wxPyBeginAllowThreads();
32359 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32360 wxPyEndAllowThreads(__tstate);
32361 if (PyErr_Occurred()) SWIG_fail;
32362 }
32363 {
32364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32365 }
32366 return resultobj;
32367 fail:
32368 return NULL;
32369 }
32370
32371
32372 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32373 PyObject *obj;
32374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32375 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32376 return SWIG_Py_Void();
32377 }
32378
32379 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 return SWIG_Python_InitShadowInstance(args);
32381 }
32382
32383 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32384 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32385 return 1;
32386 }
32387
32388
32389 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32390 PyObject *pyobj = 0;
32391
32392 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32393 return pyobj;
32394 }
32395
32396
32397 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32398 PyObject *resultobj = 0;
32399 wxString *arg1 = 0 ;
32400 wxAcceleratorEntry *result = 0 ;
32401 bool temp1 = false ;
32402 PyObject * obj0 = 0 ;
32403 char * kwnames[] = {
32404 (char *) "label", NULL
32405 };
32406
32407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32408 {
32409 arg1 = wxString_in_helper(obj0);
32410 if (arg1 == NULL) SWIG_fail;
32411 temp1 = true;
32412 }
32413 {
32414 PyThreadState* __tstate = wxPyBeginAllowThreads();
32415 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32416 wxPyEndAllowThreads(__tstate);
32417 if (PyErr_Occurred()) SWIG_fail;
32418 }
32419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32420 {
32421 if (temp1)
32422 delete arg1;
32423 }
32424 return resultobj;
32425 fail:
32426 {
32427 if (temp1)
32428 delete arg1;
32429 }
32430 return NULL;
32431 }
32432
32433
32434 SWIGINTERN int PanelNameStr_set(PyObject *) {
32435 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32436 return 1;
32437 }
32438
32439
32440 SWIGINTERN PyObject *PanelNameStr_get(void) {
32441 PyObject *pyobj = 0;
32442
32443 {
32444 #if wxUSE_UNICODE
32445 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32446 #else
32447 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32448 #endif
32449 }
32450 return pyobj;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32455 PyObject *resultobj = 0;
32456 wxVisualAttributes *result = 0 ;
32457
32458 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32459 {
32460 PyThreadState* __tstate = wxPyBeginAllowThreads();
32461 result = (wxVisualAttributes *)new_wxVisualAttributes();
32462 wxPyEndAllowThreads(__tstate);
32463 if (PyErr_Occurred()) SWIG_fail;
32464 }
32465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32466 return resultobj;
32467 fail:
32468 return NULL;
32469 }
32470
32471
32472 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32473 PyObject *resultobj = 0;
32474 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32475 void *argp1 = 0 ;
32476 int res1 = 0 ;
32477 PyObject *swig_obj[1] ;
32478
32479 if (!args) SWIG_fail;
32480 swig_obj[0] = args;
32481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32482 if (!SWIG_IsOK(res1)) {
32483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32484 }
32485 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 delete_wxVisualAttributes(arg1);
32489
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 resultobj = SWIG_Py_Void();
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32503 wxFont *arg2 = (wxFont *) 0 ;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 void *argp2 = 0 ;
32507 int res2 = 0 ;
32508 PyObject *swig_obj[2] ;
32509
32510 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32512 if (!SWIG_IsOK(res1)) {
32513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32514 }
32515 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32516 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32517 if (!SWIG_IsOK(res2)) {
32518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32519 }
32520 arg2 = reinterpret_cast< wxFont * >(argp2);
32521 if (arg1) (arg1)->font = *arg2;
32522
32523 resultobj = SWIG_Py_Void();
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32533 wxFont *result = 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32543 }
32544 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32545 result = (wxFont *)& ((arg1)->font);
32546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 PyObject *resultobj = 0;
32555 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32556 wxColour *arg2 = (wxColour *) 0 ;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 void *argp2 = 0 ;
32560 int res2 = 0 ;
32561 PyObject *swig_obj[2] ;
32562
32563 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32565 if (!SWIG_IsOK(res1)) {
32566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32567 }
32568 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32569 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32570 if (!SWIG_IsOK(res2)) {
32571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32572 }
32573 arg2 = reinterpret_cast< wxColour * >(argp2);
32574 if (arg1) (arg1)->colFg = *arg2;
32575
32576 resultobj = SWIG_Py_Void();
32577 return resultobj;
32578 fail:
32579 return NULL;
32580 }
32581
32582
32583 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32584 PyObject *resultobj = 0;
32585 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32586 wxColour *result = 0 ;
32587 void *argp1 = 0 ;
32588 int res1 = 0 ;
32589 PyObject *swig_obj[1] ;
32590
32591 if (!args) SWIG_fail;
32592 swig_obj[0] = args;
32593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32594 if (!SWIG_IsOK(res1)) {
32595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32596 }
32597 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32598 result = (wxColour *)& ((arg1)->colFg);
32599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32607 PyObject *resultobj = 0;
32608 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32609 wxColour *arg2 = (wxColour *) 0 ;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 void *argp2 = 0 ;
32613 int res2 = 0 ;
32614 PyObject *swig_obj[2] ;
32615
32616 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32618 if (!SWIG_IsOK(res1)) {
32619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32620 }
32621 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32623 if (!SWIG_IsOK(res2)) {
32624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32625 }
32626 arg2 = reinterpret_cast< wxColour * >(argp2);
32627 if (arg1) (arg1)->colBg = *arg2;
32628
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 PyObject *resultobj = 0;
32638 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32639 wxColour *result = 0 ;
32640 void *argp1 = 0 ;
32641 int res1 = 0 ;
32642 PyObject *swig_obj[1] ;
32643
32644 if (!args) SWIG_fail;
32645 swig_obj[0] = args;
32646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32647 if (!SWIG_IsOK(res1)) {
32648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32649 }
32650 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32651 result = (wxColour *)& ((arg1)->colBg);
32652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *obj;
32661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32662 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32663 return SWIG_Py_Void();
32664 }
32665
32666 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 return SWIG_Python_InitShadowInstance(args);
32668 }
32669
32670 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32671 PyObject *resultobj = 0;
32672 wxWindow *arg1 = (wxWindow *) 0 ;
32673 int arg2 = (int) (int)-1 ;
32674 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32675 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32676 wxSize const &arg4_defvalue = wxDefaultSize ;
32677 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32678 long arg5 = (long) 0 ;
32679 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32680 wxString *arg6 = (wxString *) &arg6_defvalue ;
32681 wxWindow *result = 0 ;
32682 void *argp1 = 0 ;
32683 int res1 = 0 ;
32684 int val2 ;
32685 int ecode2 = 0 ;
32686 wxPoint temp3 ;
32687 wxSize temp4 ;
32688 long val5 ;
32689 int ecode5 = 0 ;
32690 bool temp6 = false ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 PyObject * obj2 = 0 ;
32694 PyObject * obj3 = 0 ;
32695 PyObject * obj4 = 0 ;
32696 PyObject * obj5 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 if (obj1) {
32708 ecode2 = SWIG_AsVal_int(obj1, &val2);
32709 if (!SWIG_IsOK(ecode2)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32711 }
32712 arg2 = static_cast< int >(val2);
32713 }
32714 if (obj2) {
32715 {
32716 arg3 = &temp3;
32717 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32718 }
32719 }
32720 if (obj3) {
32721 {
32722 arg4 = &temp4;
32723 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32724 }
32725 }
32726 if (obj4) {
32727 ecode5 = SWIG_AsVal_long(obj4, &val5);
32728 if (!SWIG_IsOK(ecode5)) {
32729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32730 }
32731 arg5 = static_cast< long >(val5);
32732 }
32733 if (obj5) {
32734 {
32735 arg6 = wxString_in_helper(obj5);
32736 if (arg6 == NULL) SWIG_fail;
32737 temp6 = true;
32738 }
32739 }
32740 {
32741 if (!wxPyCheckForApp()) SWIG_fail;
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32748 {
32749 if (temp6)
32750 delete arg6;
32751 }
32752 return resultobj;
32753 fail:
32754 {
32755 if (temp6)
32756 delete arg6;
32757 }
32758 return NULL;
32759 }
32760
32761
32762 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32763 PyObject *resultobj = 0;
32764 wxWindow *result = 0 ;
32765
32766 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32767 {
32768 if (!wxPyCheckForApp()) SWIG_fail;
32769 PyThreadState* __tstate = wxPyBeginAllowThreads();
32770 result = (wxWindow *)new wxWindow();
32771 wxPyEndAllowThreads(__tstate);
32772 if (PyErr_Occurred()) SWIG_fail;
32773 }
32774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32775 return resultobj;
32776 fail:
32777 return NULL;
32778 }
32779
32780
32781 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32782 PyObject *resultobj = 0;
32783 wxWindow *arg1 = (wxWindow *) 0 ;
32784 wxWindow *arg2 = (wxWindow *) 0 ;
32785 int arg3 = (int) (int)-1 ;
32786 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32787 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32788 wxSize const &arg5_defvalue = wxDefaultSize ;
32789 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32790 long arg6 = (long) 0 ;
32791 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32792 wxString *arg7 = (wxString *) &arg7_defvalue ;
32793 bool result;
32794 void *argp1 = 0 ;
32795 int res1 = 0 ;
32796 void *argp2 = 0 ;
32797 int res2 = 0 ;
32798 int val3 ;
32799 int ecode3 = 0 ;
32800 wxPoint temp4 ;
32801 wxSize temp5 ;
32802 long val6 ;
32803 int ecode6 = 0 ;
32804 bool temp7 = false ;
32805 PyObject * obj0 = 0 ;
32806 PyObject * obj1 = 0 ;
32807 PyObject * obj2 = 0 ;
32808 PyObject * obj3 = 0 ;
32809 PyObject * obj4 = 0 ;
32810 PyObject * obj5 = 0 ;
32811 PyObject * obj6 = 0 ;
32812 char * kwnames[] = {
32813 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32814 };
32815
32816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32818 if (!SWIG_IsOK(res1)) {
32819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32820 }
32821 arg1 = reinterpret_cast< wxWindow * >(argp1);
32822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32823 if (!SWIG_IsOK(res2)) {
32824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32825 }
32826 arg2 = reinterpret_cast< wxWindow * >(argp2);
32827 if (obj2) {
32828 ecode3 = SWIG_AsVal_int(obj2, &val3);
32829 if (!SWIG_IsOK(ecode3)) {
32830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32831 }
32832 arg3 = static_cast< int >(val3);
32833 }
32834 if (obj3) {
32835 {
32836 arg4 = &temp4;
32837 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32838 }
32839 }
32840 if (obj4) {
32841 {
32842 arg5 = &temp5;
32843 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32844 }
32845 }
32846 if (obj5) {
32847 ecode6 = SWIG_AsVal_long(obj5, &val6);
32848 if (!SWIG_IsOK(ecode6)) {
32849 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32850 }
32851 arg6 = static_cast< long >(val6);
32852 }
32853 if (obj6) {
32854 {
32855 arg7 = wxString_in_helper(obj6);
32856 if (arg7 == NULL) SWIG_fail;
32857 temp7 = true;
32858 }
32859 }
32860 {
32861 PyThreadState* __tstate = wxPyBeginAllowThreads();
32862 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32863 wxPyEndAllowThreads(__tstate);
32864 if (PyErr_Occurred()) SWIG_fail;
32865 }
32866 {
32867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32868 }
32869 {
32870 if (temp7)
32871 delete arg7;
32872 }
32873 return resultobj;
32874 fail:
32875 {
32876 if (temp7)
32877 delete arg7;
32878 }
32879 return NULL;
32880 }
32881
32882
32883 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32884 PyObject *resultobj = 0;
32885 wxWindow *arg1 = (wxWindow *) 0 ;
32886 bool arg2 = (bool) false ;
32887 bool result;
32888 void *argp1 = 0 ;
32889 int res1 = 0 ;
32890 bool val2 ;
32891 int ecode2 = 0 ;
32892 PyObject * obj0 = 0 ;
32893 PyObject * obj1 = 0 ;
32894 char * kwnames[] = {
32895 (char *) "self",(char *) "force", NULL
32896 };
32897
32898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32900 if (!SWIG_IsOK(res1)) {
32901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32902 }
32903 arg1 = reinterpret_cast< wxWindow * >(argp1);
32904 if (obj1) {
32905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32906 if (!SWIG_IsOK(ecode2)) {
32907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32908 }
32909 arg2 = static_cast< bool >(val2);
32910 }
32911 {
32912 PyThreadState* __tstate = wxPyBeginAllowThreads();
32913 result = (bool)(arg1)->Close(arg2);
32914 wxPyEndAllowThreads(__tstate);
32915 if (PyErr_Occurred()) SWIG_fail;
32916 }
32917 {
32918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32919 }
32920 return resultobj;
32921 fail:
32922 return NULL;
32923 }
32924
32925
32926 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32927 PyObject *resultobj = 0;
32928 wxWindow *arg1 = (wxWindow *) 0 ;
32929 bool result;
32930 void *argp1 = 0 ;
32931 int res1 = 0 ;
32932 PyObject *swig_obj[1] ;
32933
32934 if (!args) SWIG_fail;
32935 swig_obj[0] = args;
32936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32937 if (!SWIG_IsOK(res1)) {
32938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32939 }
32940 arg1 = reinterpret_cast< wxWindow * >(argp1);
32941 {
32942 PyThreadState* __tstate = wxPyBeginAllowThreads();
32943 result = (bool)(arg1)->Destroy();
32944 wxPyEndAllowThreads(__tstate);
32945 if (PyErr_Occurred()) SWIG_fail;
32946 }
32947 {
32948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32949 }
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32957 PyObject *resultobj = 0;
32958 wxWindow *arg1 = (wxWindow *) 0 ;
32959 bool result;
32960 void *argp1 = 0 ;
32961 int res1 = 0 ;
32962 PyObject *swig_obj[1] ;
32963
32964 if (!args) SWIG_fail;
32965 swig_obj[0] = args;
32966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32969 }
32970 arg1 = reinterpret_cast< wxWindow * >(argp1);
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 result = (bool)(arg1)->DestroyChildren();
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 {
32978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32979 }
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32987 PyObject *resultobj = 0;
32988 wxWindow *arg1 = (wxWindow *) 0 ;
32989 bool result;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 PyObject *swig_obj[1] ;
32993
32994 if (!args) SWIG_fail;
32995 swig_obj[0] = args;
32996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32997 if (!SWIG_IsOK(res1)) {
32998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
32999 }
33000 arg1 = reinterpret_cast< wxWindow * >(argp1);
33001 {
33002 PyThreadState* __tstate = wxPyBeginAllowThreads();
33003 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33004 wxPyEndAllowThreads(__tstate);
33005 if (PyErr_Occurred()) SWIG_fail;
33006 }
33007 {
33008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33009 }
33010 return resultobj;
33011 fail:
33012 return NULL;
33013 }
33014
33015
33016 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33017 PyObject *resultobj = 0;
33018 wxWindow *arg1 = (wxWindow *) 0 ;
33019 wxString *arg2 = 0 ;
33020 void *argp1 = 0 ;
33021 int res1 = 0 ;
33022 bool temp2 = false ;
33023 PyObject * obj0 = 0 ;
33024 PyObject * obj1 = 0 ;
33025 char * kwnames[] = {
33026 (char *) "self",(char *) "label", NULL
33027 };
33028
33029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33031 if (!SWIG_IsOK(res1)) {
33032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33033 }
33034 arg1 = reinterpret_cast< wxWindow * >(argp1);
33035 {
33036 arg2 = wxString_in_helper(obj1);
33037 if (arg2 == NULL) SWIG_fail;
33038 temp2 = true;
33039 }
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 (arg1)->SetLabel((wxString const &)*arg2);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_Py_Void();
33047 {
33048 if (temp2)
33049 delete arg2;
33050 }
33051 return resultobj;
33052 fail:
33053 {
33054 if (temp2)
33055 delete arg2;
33056 }
33057 return NULL;
33058 }
33059
33060
33061 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33062 PyObject *resultobj = 0;
33063 wxWindow *arg1 = (wxWindow *) 0 ;
33064 wxString result;
33065 void *argp1 = 0 ;
33066 int res1 = 0 ;
33067 PyObject *swig_obj[1] ;
33068
33069 if (!args) SWIG_fail;
33070 swig_obj[0] = args;
33071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33072 if (!SWIG_IsOK(res1)) {
33073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33074 }
33075 arg1 = reinterpret_cast< wxWindow * >(argp1);
33076 {
33077 PyThreadState* __tstate = wxPyBeginAllowThreads();
33078 result = ((wxWindow const *)arg1)->GetLabel();
33079 wxPyEndAllowThreads(__tstate);
33080 if (PyErr_Occurred()) SWIG_fail;
33081 }
33082 {
33083 #if wxUSE_UNICODE
33084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33085 #else
33086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33087 #endif
33088 }
33089 return resultobj;
33090 fail:
33091 return NULL;
33092 }
33093
33094
33095 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33096 PyObject *resultobj = 0;
33097 wxWindow *arg1 = (wxWindow *) 0 ;
33098 wxString *arg2 = 0 ;
33099 void *argp1 = 0 ;
33100 int res1 = 0 ;
33101 bool temp2 = false ;
33102 PyObject * obj0 = 0 ;
33103 PyObject * obj1 = 0 ;
33104 char * kwnames[] = {
33105 (char *) "self",(char *) "name", NULL
33106 };
33107
33108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33110 if (!SWIG_IsOK(res1)) {
33111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33112 }
33113 arg1 = reinterpret_cast< wxWindow * >(argp1);
33114 {
33115 arg2 = wxString_in_helper(obj1);
33116 if (arg2 == NULL) SWIG_fail;
33117 temp2 = true;
33118 }
33119 {
33120 PyThreadState* __tstate = wxPyBeginAllowThreads();
33121 (arg1)->SetName((wxString const &)*arg2);
33122 wxPyEndAllowThreads(__tstate);
33123 if (PyErr_Occurred()) SWIG_fail;
33124 }
33125 resultobj = SWIG_Py_Void();
33126 {
33127 if (temp2)
33128 delete arg2;
33129 }
33130 return resultobj;
33131 fail:
33132 {
33133 if (temp2)
33134 delete arg2;
33135 }
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 wxString result;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = ((wxWindow const *)arg1)->GetName();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 {
33162 #if wxUSE_UNICODE
33163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33164 #else
33165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33166 #endif
33167 }
33168 return resultobj;
33169 fail:
33170 return NULL;
33171 }
33172
33173
33174 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33175 PyObject *resultobj = 0;
33176 wxWindow *arg1 = (wxWindow *) 0 ;
33177 wxWindowVariant arg2 ;
33178 void *argp1 = 0 ;
33179 int res1 = 0 ;
33180 int val2 ;
33181 int ecode2 = 0 ;
33182 PyObject * obj0 = 0 ;
33183 PyObject * obj1 = 0 ;
33184 char * kwnames[] = {
33185 (char *) "self",(char *) "variant", NULL
33186 };
33187
33188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33190 if (!SWIG_IsOK(res1)) {
33191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33192 }
33193 arg1 = reinterpret_cast< wxWindow * >(argp1);
33194 ecode2 = SWIG_AsVal_int(obj1, &val2);
33195 if (!SWIG_IsOK(ecode2)) {
33196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33197 }
33198 arg2 = static_cast< wxWindowVariant >(val2);
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 (arg1)->SetWindowVariant(arg2);
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_Py_Void();
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 wxWindowVariant result;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 PyObject *swig_obj[1] ;
33219
33220 if (!args) SWIG_fail;
33221 swig_obj[0] = args;
33222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33223 if (!SWIG_IsOK(res1)) {
33224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33225 }
33226 arg1 = reinterpret_cast< wxWindow * >(argp1);
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33230 wxPyEndAllowThreads(__tstate);
33231 if (PyErr_Occurred()) SWIG_fail;
33232 }
33233 resultobj = SWIG_From_int(static_cast< int >(result));
33234 return resultobj;
33235 fail:
33236 return NULL;
33237 }
33238
33239
33240 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33241 PyObject *resultobj = 0;
33242 wxWindow *arg1 = (wxWindow *) 0 ;
33243 int arg2 ;
33244 void *argp1 = 0 ;
33245 int res1 = 0 ;
33246 int val2 ;
33247 int ecode2 = 0 ;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 char * kwnames[] = {
33251 (char *) "self",(char *) "winid", NULL
33252 };
33253
33254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33258 }
33259 arg1 = reinterpret_cast< wxWindow * >(argp1);
33260 ecode2 = SWIG_AsVal_int(obj1, &val2);
33261 if (!SWIG_IsOK(ecode2)) {
33262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33263 }
33264 arg2 = static_cast< int >(val2);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 (arg1)->SetId(arg2);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 resultobj = SWIG_Py_Void();
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33279 PyObject *resultobj = 0;
33280 wxWindow *arg1 = (wxWindow *) 0 ;
33281 int result;
33282 void *argp1 = 0 ;
33283 int res1 = 0 ;
33284 PyObject *swig_obj[1] ;
33285
33286 if (!args) SWIG_fail;
33287 swig_obj[0] = args;
33288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33291 }
33292 arg1 = reinterpret_cast< wxWindow * >(argp1);
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (int)((wxWindow const *)arg1)->GetId();
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 resultobj = SWIG_From_int(static_cast< int >(result));
33300 return resultobj;
33301 fail:
33302 return NULL;
33303 }
33304
33305
33306 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33307 PyObject *resultobj = 0;
33308 int result;
33309
33310 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 result = (int)wxWindow::NewControlId();
33314 wxPyEndAllowThreads(__tstate);
33315 if (PyErr_Occurred()) SWIG_fail;
33316 }
33317 resultobj = SWIG_From_int(static_cast< int >(result));
33318 return resultobj;
33319 fail:
33320 return NULL;
33321 }
33322
33323
33324 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33325 PyObject *resultobj = 0;
33326 int arg1 ;
33327 int result;
33328 int val1 ;
33329 int ecode1 = 0 ;
33330 PyObject * obj0 = 0 ;
33331 char * kwnames[] = {
33332 (char *) "winid", NULL
33333 };
33334
33335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33336 ecode1 = SWIG_AsVal_int(obj0, &val1);
33337 if (!SWIG_IsOK(ecode1)) {
33338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33339 }
33340 arg1 = static_cast< int >(val1);
33341 {
33342 PyThreadState* __tstate = wxPyBeginAllowThreads();
33343 result = (int)wxWindow::NextControlId(arg1);
33344 wxPyEndAllowThreads(__tstate);
33345 if (PyErr_Occurred()) SWIG_fail;
33346 }
33347 resultobj = SWIG_From_int(static_cast< int >(result));
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33355 PyObject *resultobj = 0;
33356 int arg1 ;
33357 int result;
33358 int val1 ;
33359 int ecode1 = 0 ;
33360 PyObject * obj0 = 0 ;
33361 char * kwnames[] = {
33362 (char *) "winid", NULL
33363 };
33364
33365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33366 ecode1 = SWIG_AsVal_int(obj0, &val1);
33367 if (!SWIG_IsOK(ecode1)) {
33368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33369 }
33370 arg1 = static_cast< int >(val1);
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 result = (int)wxWindow::PrevControlId(arg1);
33374 wxPyEndAllowThreads(__tstate);
33375 if (PyErr_Occurred()) SWIG_fail;
33376 }
33377 resultobj = SWIG_From_int(static_cast< int >(result));
33378 return resultobj;
33379 fail:
33380 return NULL;
33381 }
33382
33383
33384 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33385 PyObject *resultobj = 0;
33386 wxWindow *arg1 = (wxWindow *) 0 ;
33387 wxLayoutDirection result;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 PyObject *swig_obj[1] ;
33391
33392 if (!args) SWIG_fail;
33393 swig_obj[0] = args;
33394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33395 if (!SWIG_IsOK(res1)) {
33396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33397 }
33398 arg1 = reinterpret_cast< wxWindow * >(argp1);
33399 {
33400 PyThreadState* __tstate = wxPyBeginAllowThreads();
33401 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33402 wxPyEndAllowThreads(__tstate);
33403 if (PyErr_Occurred()) SWIG_fail;
33404 }
33405 resultobj = SWIG_From_int(static_cast< int >(result));
33406 return resultobj;
33407 fail:
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33413 PyObject *resultobj = 0;
33414 wxWindow *arg1 = (wxWindow *) 0 ;
33415 wxLayoutDirection arg2 ;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 int val2 ;
33419 int ecode2 = 0 ;
33420 PyObject * obj0 = 0 ;
33421 PyObject * obj1 = 0 ;
33422 char * kwnames[] = {
33423 (char *) "self",(char *) "dir", NULL
33424 };
33425
33426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33428 if (!SWIG_IsOK(res1)) {
33429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33430 }
33431 arg1 = reinterpret_cast< wxWindow * >(argp1);
33432 ecode2 = SWIG_AsVal_int(obj1, &val2);
33433 if (!SWIG_IsOK(ecode2)) {
33434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33435 }
33436 arg2 = static_cast< wxLayoutDirection >(val2);
33437 {
33438 PyThreadState* __tstate = wxPyBeginAllowThreads();
33439 (arg1)->SetLayoutDirection(arg2);
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 resultobj = SWIG_Py_Void();
33444 return resultobj;
33445 fail:
33446 return NULL;
33447 }
33448
33449
33450 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj = 0;
33452 wxWindow *arg1 = (wxWindow *) 0 ;
33453 int arg2 ;
33454 int arg3 ;
33455 int arg4 ;
33456 int result;
33457 void *argp1 = 0 ;
33458 int res1 = 0 ;
33459 int val2 ;
33460 int ecode2 = 0 ;
33461 int val3 ;
33462 int ecode3 = 0 ;
33463 int val4 ;
33464 int ecode4 = 0 ;
33465 PyObject * obj0 = 0 ;
33466 PyObject * obj1 = 0 ;
33467 PyObject * obj2 = 0 ;
33468 PyObject * obj3 = 0 ;
33469 char * kwnames[] = {
33470 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33471 };
33472
33473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33475 if (!SWIG_IsOK(res1)) {
33476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33477 }
33478 arg1 = reinterpret_cast< wxWindow * >(argp1);
33479 ecode2 = SWIG_AsVal_int(obj1, &val2);
33480 if (!SWIG_IsOK(ecode2)) {
33481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33482 }
33483 arg2 = static_cast< int >(val2);
33484 ecode3 = SWIG_AsVal_int(obj2, &val3);
33485 if (!SWIG_IsOK(ecode3)) {
33486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33487 }
33488 arg3 = static_cast< int >(val3);
33489 ecode4 = SWIG_AsVal_int(obj3, &val4);
33490 if (!SWIG_IsOK(ecode4)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33492 }
33493 arg4 = static_cast< int >(val4);
33494 {
33495 PyThreadState* __tstate = wxPyBeginAllowThreads();
33496 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33497 wxPyEndAllowThreads(__tstate);
33498 if (PyErr_Occurred()) SWIG_fail;
33499 }
33500 resultobj = SWIG_From_int(static_cast< int >(result));
33501 return resultobj;
33502 fail:
33503 return NULL;
33504 }
33505
33506
33507 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33508 PyObject *resultobj = 0;
33509 wxWindow *arg1 = (wxWindow *) 0 ;
33510 wxSize *arg2 = 0 ;
33511 void *argp1 = 0 ;
33512 int res1 = 0 ;
33513 wxSize temp2 ;
33514 PyObject * obj0 = 0 ;
33515 PyObject * obj1 = 0 ;
33516 char * kwnames[] = {
33517 (char *) "self",(char *) "size", NULL
33518 };
33519
33520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33522 if (!SWIG_IsOK(res1)) {
33523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33524 }
33525 arg1 = reinterpret_cast< wxWindow * >(argp1);
33526 {
33527 arg2 = &temp2;
33528 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33529 }
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 (arg1)->SetSize((wxSize const &)*arg2);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 resultobj = SWIG_Py_Void();
33537 return resultobj;
33538 fail:
33539 return NULL;
33540 }
33541
33542
33543 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33544 PyObject *resultobj = 0;
33545 wxWindow *arg1 = (wxWindow *) 0 ;
33546 int arg2 ;
33547 int arg3 ;
33548 int arg4 ;
33549 int arg5 ;
33550 int arg6 = (int) wxSIZE_AUTO ;
33551 void *argp1 = 0 ;
33552 int res1 = 0 ;
33553 int val2 ;
33554 int ecode2 = 0 ;
33555 int val3 ;
33556 int ecode3 = 0 ;
33557 int val4 ;
33558 int ecode4 = 0 ;
33559 int val5 ;
33560 int ecode5 = 0 ;
33561 int val6 ;
33562 int ecode6 = 0 ;
33563 PyObject * obj0 = 0 ;
33564 PyObject * obj1 = 0 ;
33565 PyObject * obj2 = 0 ;
33566 PyObject * obj3 = 0 ;
33567 PyObject * obj4 = 0 ;
33568 PyObject * obj5 = 0 ;
33569 char * kwnames[] = {
33570 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33571 };
33572
33573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33577 }
33578 arg1 = reinterpret_cast< wxWindow * >(argp1);
33579 ecode2 = SWIG_AsVal_int(obj1, &val2);
33580 if (!SWIG_IsOK(ecode2)) {
33581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33582 }
33583 arg2 = static_cast< int >(val2);
33584 ecode3 = SWIG_AsVal_int(obj2, &val3);
33585 if (!SWIG_IsOK(ecode3)) {
33586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33587 }
33588 arg3 = static_cast< int >(val3);
33589 ecode4 = SWIG_AsVal_int(obj3, &val4);
33590 if (!SWIG_IsOK(ecode4)) {
33591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33592 }
33593 arg4 = static_cast< int >(val4);
33594 ecode5 = SWIG_AsVal_int(obj4, &val5);
33595 if (!SWIG_IsOK(ecode5)) {
33596 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33597 }
33598 arg5 = static_cast< int >(val5);
33599 if (obj5) {
33600 ecode6 = SWIG_AsVal_int(obj5, &val6);
33601 if (!SWIG_IsOK(ecode6)) {
33602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33603 }
33604 arg6 = static_cast< int >(val6);
33605 }
33606 {
33607 PyThreadState* __tstate = wxPyBeginAllowThreads();
33608 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33609 wxPyEndAllowThreads(__tstate);
33610 if (PyErr_Occurred()) SWIG_fail;
33611 }
33612 resultobj = SWIG_Py_Void();
33613 return resultobj;
33614 fail:
33615 return NULL;
33616 }
33617
33618
33619 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33620 PyObject *resultobj = 0;
33621 wxWindow *arg1 = (wxWindow *) 0 ;
33622 wxRect *arg2 = 0 ;
33623 int arg3 = (int) wxSIZE_AUTO ;
33624 void *argp1 = 0 ;
33625 int res1 = 0 ;
33626 wxRect temp2 ;
33627 int val3 ;
33628 int ecode3 = 0 ;
33629 PyObject * obj0 = 0 ;
33630 PyObject * obj1 = 0 ;
33631 PyObject * obj2 = 0 ;
33632 char * kwnames[] = {
33633 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33634 };
33635
33636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33638 if (!SWIG_IsOK(res1)) {
33639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33640 }
33641 arg1 = reinterpret_cast< wxWindow * >(argp1);
33642 {
33643 arg2 = &temp2;
33644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33645 }
33646 if (obj2) {
33647 ecode3 = SWIG_AsVal_int(obj2, &val3);
33648 if (!SWIG_IsOK(ecode3)) {
33649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33650 }
33651 arg3 = static_cast< int >(val3);
33652 }
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 resultobj = SWIG_Py_Void();
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj = 0;
33668 wxWindow *arg1 = (wxWindow *) 0 ;
33669 int arg2 ;
33670 int arg3 ;
33671 void *argp1 = 0 ;
33672 int res1 = 0 ;
33673 int val2 ;
33674 int ecode2 = 0 ;
33675 int val3 ;
33676 int ecode3 = 0 ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 PyObject * obj2 = 0 ;
33680 char * kwnames[] = {
33681 (char *) "self",(char *) "width",(char *) "height", NULL
33682 };
33683
33684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33686 if (!SWIG_IsOK(res1)) {
33687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33688 }
33689 arg1 = reinterpret_cast< wxWindow * >(argp1);
33690 ecode2 = SWIG_AsVal_int(obj1, &val2);
33691 if (!SWIG_IsOK(ecode2)) {
33692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33693 }
33694 arg2 = static_cast< int >(val2);
33695 ecode3 = SWIG_AsVal_int(obj2, &val3);
33696 if (!SWIG_IsOK(ecode3)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33698 }
33699 arg3 = static_cast< int >(val3);
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 (arg1)->SetSize(arg2,arg3);
33703 wxPyEndAllowThreads(__tstate);
33704 if (PyErr_Occurred()) SWIG_fail;
33705 }
33706 resultobj = SWIG_Py_Void();
33707 return resultobj;
33708 fail:
33709 return NULL;
33710 }
33711
33712
33713 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33714 PyObject *resultobj = 0;
33715 wxWindow *arg1 = (wxWindow *) 0 ;
33716 wxPoint *arg2 = 0 ;
33717 int arg3 = (int) wxSIZE_USE_EXISTING ;
33718 void *argp1 = 0 ;
33719 int res1 = 0 ;
33720 wxPoint temp2 ;
33721 int val3 ;
33722 int ecode3 = 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 PyObject * obj2 = 0 ;
33726 char * kwnames[] = {
33727 (char *) "self",(char *) "pt",(char *) "flags", NULL
33728 };
33729
33730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33732 if (!SWIG_IsOK(res1)) {
33733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33734 }
33735 arg1 = reinterpret_cast< wxWindow * >(argp1);
33736 {
33737 arg2 = &temp2;
33738 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33739 }
33740 if (obj2) {
33741 ecode3 = SWIG_AsVal_int(obj2, &val3);
33742 if (!SWIG_IsOK(ecode3)) {
33743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33744 }
33745 arg3 = static_cast< int >(val3);
33746 }
33747 {
33748 PyThreadState* __tstate = wxPyBeginAllowThreads();
33749 (arg1)->Move((wxPoint const &)*arg2,arg3);
33750 wxPyEndAllowThreads(__tstate);
33751 if (PyErr_Occurred()) SWIG_fail;
33752 }
33753 resultobj = SWIG_Py_Void();
33754 return resultobj;
33755 fail:
33756 return NULL;
33757 }
33758
33759
33760 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33761 PyObject *resultobj = 0;
33762 wxWindow *arg1 = (wxWindow *) 0 ;
33763 int arg2 ;
33764 int arg3 ;
33765 int arg4 = (int) wxSIZE_USE_EXISTING ;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 int val2 ;
33769 int ecode2 = 0 ;
33770 int val3 ;
33771 int ecode3 = 0 ;
33772 int val4 ;
33773 int ecode4 = 0 ;
33774 PyObject * obj0 = 0 ;
33775 PyObject * obj1 = 0 ;
33776 PyObject * obj2 = 0 ;
33777 PyObject * obj3 = 0 ;
33778 char * kwnames[] = {
33779 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33780 };
33781
33782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33784 if (!SWIG_IsOK(res1)) {
33785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33786 }
33787 arg1 = reinterpret_cast< wxWindow * >(argp1);
33788 ecode2 = SWIG_AsVal_int(obj1, &val2);
33789 if (!SWIG_IsOK(ecode2)) {
33790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33791 }
33792 arg2 = static_cast< int >(val2);
33793 ecode3 = SWIG_AsVal_int(obj2, &val3);
33794 if (!SWIG_IsOK(ecode3)) {
33795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33796 }
33797 arg3 = static_cast< int >(val3);
33798 if (obj3) {
33799 ecode4 = SWIG_AsVal_int(obj3, &val4);
33800 if (!SWIG_IsOK(ecode4)) {
33801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33802 }
33803 arg4 = static_cast< int >(val4);
33804 }
33805 {
33806 PyThreadState* __tstate = wxPyBeginAllowThreads();
33807 (arg1)->Move(arg2,arg3,arg4);
33808 wxPyEndAllowThreads(__tstate);
33809 if (PyErr_Occurred()) SWIG_fail;
33810 }
33811 resultobj = SWIG_Py_Void();
33812 return resultobj;
33813 fail:
33814 return NULL;
33815 }
33816
33817
33818 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33819 PyObject *resultobj = 0;
33820 wxWindow *arg1 = (wxWindow *) 0 ;
33821 wxSize const &arg2_defvalue = wxDefaultSize ;
33822 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 wxSize temp2 ;
33826 PyObject * obj0 = 0 ;
33827 PyObject * obj1 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "size", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 if (obj1) {
33839 {
33840 arg2 = &temp2;
33841 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33842 }
33843 }
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 (arg1)->SetInitialSize((wxSize const &)*arg2);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_Py_Void();
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 void *argp1 = 0 ;
33861 int res1 = 0 ;
33862 PyObject *swig_obj[1] ;
33863
33864 if (!args) SWIG_fail;
33865 swig_obj[0] = args;
33866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33867 if (!SWIG_IsOK(res1)) {
33868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33869 }
33870 arg1 = reinterpret_cast< wxWindow * >(argp1);
33871 {
33872 PyThreadState* __tstate = wxPyBeginAllowThreads();
33873 (arg1)->Raise();
33874 wxPyEndAllowThreads(__tstate);
33875 if (PyErr_Occurred()) SWIG_fail;
33876 }
33877 resultobj = SWIG_Py_Void();
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33885 PyObject *resultobj = 0;
33886 wxWindow *arg1 = (wxWindow *) 0 ;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33896 }
33897 arg1 = reinterpret_cast< wxWindow * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 (arg1)->Lower();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 resultobj = SWIG_Py_Void();
33905 return resultobj;
33906 fail:
33907 return NULL;
33908 }
33909
33910
33911 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33912 PyObject *resultobj = 0;
33913 wxWindow *arg1 = (wxWindow *) 0 ;
33914 wxSize *arg2 = 0 ;
33915 void *argp1 = 0 ;
33916 int res1 = 0 ;
33917 wxSize temp2 ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 char * kwnames[] = {
33921 (char *) "self",(char *) "size", NULL
33922 };
33923
33924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33926 if (!SWIG_IsOK(res1)) {
33927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33928 }
33929 arg1 = reinterpret_cast< wxWindow * >(argp1);
33930 {
33931 arg2 = &temp2;
33932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33933 }
33934 {
33935 PyThreadState* __tstate = wxPyBeginAllowThreads();
33936 (arg1)->SetClientSize((wxSize const &)*arg2);
33937 wxPyEndAllowThreads(__tstate);
33938 if (PyErr_Occurred()) SWIG_fail;
33939 }
33940 resultobj = SWIG_Py_Void();
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj = 0;
33949 wxWindow *arg1 = (wxWindow *) 0 ;
33950 int arg2 ;
33951 int arg3 ;
33952 void *argp1 = 0 ;
33953 int res1 = 0 ;
33954 int val2 ;
33955 int ecode2 = 0 ;
33956 int val3 ;
33957 int ecode3 = 0 ;
33958 PyObject * obj0 = 0 ;
33959 PyObject * obj1 = 0 ;
33960 PyObject * obj2 = 0 ;
33961 char * kwnames[] = {
33962 (char *) "self",(char *) "width",(char *) "height", NULL
33963 };
33964
33965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33969 }
33970 arg1 = reinterpret_cast< wxWindow * >(argp1);
33971 ecode2 = SWIG_AsVal_int(obj1, &val2);
33972 if (!SWIG_IsOK(ecode2)) {
33973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33974 }
33975 arg2 = static_cast< int >(val2);
33976 ecode3 = SWIG_AsVal_int(obj2, &val3);
33977 if (!SWIG_IsOK(ecode3)) {
33978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33979 }
33980 arg3 = static_cast< int >(val3);
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 (arg1)->SetClientSize(arg2,arg3);
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_Py_Void();
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33995 PyObject *resultobj = 0;
33996 wxWindow *arg1 = (wxWindow *) 0 ;
33997 wxRect *arg2 = 0 ;
33998 void *argp1 = 0 ;
33999 int res1 = 0 ;
34000 wxRect temp2 ;
34001 PyObject * obj0 = 0 ;
34002 PyObject * obj1 = 0 ;
34003 char * kwnames[] = {
34004 (char *) "self",(char *) "rect", NULL
34005 };
34006
34007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34009 if (!SWIG_IsOK(res1)) {
34010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34011 }
34012 arg1 = reinterpret_cast< wxWindow * >(argp1);
34013 {
34014 arg2 = &temp2;
34015 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34016 }
34017 {
34018 PyThreadState* __tstate = wxPyBeginAllowThreads();
34019 (arg1)->SetClientSize((wxRect const &)*arg2);
34020 wxPyEndAllowThreads(__tstate);
34021 if (PyErr_Occurred()) SWIG_fail;
34022 }
34023 resultobj = SWIG_Py_Void();
34024 return resultobj;
34025 fail:
34026 return NULL;
34027 }
34028
34029
34030 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34031 PyObject *resultobj = 0;
34032 wxWindow *arg1 = (wxWindow *) 0 ;
34033 wxPoint result;
34034 void *argp1 = 0 ;
34035 int res1 = 0 ;
34036 PyObject *swig_obj[1] ;
34037
34038 if (!args) SWIG_fail;
34039 swig_obj[0] = args;
34040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34041 if (!SWIG_IsOK(res1)) {
34042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34043 }
34044 arg1 = reinterpret_cast< wxWindow * >(argp1);
34045 {
34046 PyThreadState* __tstate = wxPyBeginAllowThreads();
34047 result = ((wxWindow const *)arg1)->GetPosition();
34048 wxPyEndAllowThreads(__tstate);
34049 if (PyErr_Occurred()) SWIG_fail;
34050 }
34051 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34052 return resultobj;
34053 fail:
34054 return NULL;
34055 }
34056
34057
34058 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34059 PyObject *resultobj = 0;
34060 wxWindow *arg1 = (wxWindow *) 0 ;
34061 int *arg2 = (int *) 0 ;
34062 int *arg3 = (int *) 0 ;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 int temp2 ;
34066 int res2 = SWIG_TMPOBJ ;
34067 int temp3 ;
34068 int res3 = SWIG_TMPOBJ ;
34069 PyObject *swig_obj[1] ;
34070
34071 arg2 = &temp2;
34072 arg3 = &temp3;
34073 if (!args) SWIG_fail;
34074 swig_obj[0] = args;
34075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34078 }
34079 arg1 = reinterpret_cast< wxWindow * >(argp1);
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = SWIG_Py_Void();
34087 if (SWIG_IsTmpObj(res2)) {
34088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34089 } else {
34090 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34092 }
34093 if (SWIG_IsTmpObj(res3)) {
34094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34095 } else {
34096 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34098 }
34099 return resultobj;
34100 fail:
34101 return NULL;
34102 }
34103
34104
34105 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34106 PyObject *resultobj = 0;
34107 wxWindow *arg1 = (wxWindow *) 0 ;
34108 wxPoint result;
34109 void *argp1 = 0 ;
34110 int res1 = 0 ;
34111 PyObject *swig_obj[1] ;
34112
34113 if (!args) SWIG_fail;
34114 swig_obj[0] = args;
34115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = ((wxWindow const *)arg1)->GetScreenPosition();
34123 wxPyEndAllowThreads(__tstate);
34124 if (PyErr_Occurred()) SWIG_fail;
34125 }
34126 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34134 PyObject *resultobj = 0;
34135 wxWindow *arg1 = (wxWindow *) 0 ;
34136 int *arg2 = (int *) 0 ;
34137 int *arg3 = (int *) 0 ;
34138 void *argp1 = 0 ;
34139 int res1 = 0 ;
34140 int temp2 ;
34141 int res2 = SWIG_TMPOBJ ;
34142 int temp3 ;
34143 int res3 = SWIG_TMPOBJ ;
34144 PyObject *swig_obj[1] ;
34145
34146 arg2 = &temp2;
34147 arg3 = &temp3;
34148 if (!args) SWIG_fail;
34149 swig_obj[0] = args;
34150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34151 if (!SWIG_IsOK(res1)) {
34152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34153 }
34154 arg1 = reinterpret_cast< wxWindow * >(argp1);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_Py_Void();
34162 if (SWIG_IsTmpObj(res2)) {
34163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34164 } else {
34165 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34167 }
34168 if (SWIG_IsTmpObj(res3)) {
34169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34170 } else {
34171 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34173 }
34174 return resultobj;
34175 fail:
34176 return NULL;
34177 }
34178
34179
34180 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34181 PyObject *resultobj = 0;
34182 wxWindow *arg1 = (wxWindow *) 0 ;
34183 wxRect result;
34184 void *argp1 = 0 ;
34185 int res1 = 0 ;
34186 PyObject *swig_obj[1] ;
34187
34188 if (!args) SWIG_fail;
34189 swig_obj[0] = args;
34190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34191 if (!SWIG_IsOK(res1)) {
34192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34193 }
34194 arg1 = reinterpret_cast< wxWindow * >(argp1);
34195 {
34196 PyThreadState* __tstate = wxPyBeginAllowThreads();
34197 result = ((wxWindow const *)arg1)->GetScreenRect();
34198 wxPyEndAllowThreads(__tstate);
34199 if (PyErr_Occurred()) SWIG_fail;
34200 }
34201 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34202 return resultobj;
34203 fail:
34204 return NULL;
34205 }
34206
34207
34208 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34209 PyObject *resultobj = 0;
34210 wxWindow *arg1 = (wxWindow *) 0 ;
34211 wxSize result;
34212 void *argp1 = 0 ;
34213 int res1 = 0 ;
34214 PyObject *swig_obj[1] ;
34215
34216 if (!args) SWIG_fail;
34217 swig_obj[0] = args;
34218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34219 if (!SWIG_IsOK(res1)) {
34220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34221 }
34222 arg1 = reinterpret_cast< wxWindow * >(argp1);
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 result = ((wxWindow const *)arg1)->GetSize();
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 int *arg2 = (int *) 0 ;
34240 int *arg3 = (int *) 0 ;
34241 void *argp1 = 0 ;
34242 int res1 = 0 ;
34243 int temp2 ;
34244 int res2 = SWIG_TMPOBJ ;
34245 int temp3 ;
34246 int res3 = SWIG_TMPOBJ ;
34247 PyObject *swig_obj[1] ;
34248
34249 arg2 = &temp2;
34250 arg3 = &temp3;
34251 if (!args) SWIG_fail;
34252 swig_obj[0] = args;
34253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34254 if (!SWIG_IsOK(res1)) {
34255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34256 }
34257 arg1 = reinterpret_cast< wxWindow * >(argp1);
34258 {
34259 PyThreadState* __tstate = wxPyBeginAllowThreads();
34260 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34261 wxPyEndAllowThreads(__tstate);
34262 if (PyErr_Occurred()) SWIG_fail;
34263 }
34264 resultobj = SWIG_Py_Void();
34265 if (SWIG_IsTmpObj(res2)) {
34266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34267 } else {
34268 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34270 }
34271 if (SWIG_IsTmpObj(res3)) {
34272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34273 } else {
34274 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34276 }
34277 return resultobj;
34278 fail:
34279 return NULL;
34280 }
34281
34282
34283 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34284 PyObject *resultobj = 0;
34285 wxWindow *arg1 = (wxWindow *) 0 ;
34286 wxRect result;
34287 void *argp1 = 0 ;
34288 int res1 = 0 ;
34289 PyObject *swig_obj[1] ;
34290
34291 if (!args) SWIG_fail;
34292 swig_obj[0] = args;
34293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34294 if (!SWIG_IsOK(res1)) {
34295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34296 }
34297 arg1 = reinterpret_cast< wxWindow * >(argp1);
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 result = ((wxWindow const *)arg1)->GetRect();
34301 wxPyEndAllowThreads(__tstate);
34302 if (PyErr_Occurred()) SWIG_fail;
34303 }
34304 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34312 PyObject *resultobj = 0;
34313 wxWindow *arg1 = (wxWindow *) 0 ;
34314 wxSize result;
34315 void *argp1 = 0 ;
34316 int res1 = 0 ;
34317 PyObject *swig_obj[1] ;
34318
34319 if (!args) SWIG_fail;
34320 swig_obj[0] = args;
34321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34322 if (!SWIG_IsOK(res1)) {
34323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34324 }
34325 arg1 = reinterpret_cast< wxWindow * >(argp1);
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = ((wxWindow const *)arg1)->GetClientSize();
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 int *arg2 = (int *) 0 ;
34343 int *arg3 = (int *) 0 ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 int temp2 ;
34347 int res2 = SWIG_TMPOBJ ;
34348 int temp3 ;
34349 int res3 = SWIG_TMPOBJ ;
34350 PyObject *swig_obj[1] ;
34351
34352 arg2 = &temp2;
34353 arg3 = &temp3;
34354 if (!args) SWIG_fail;
34355 swig_obj[0] = args;
34356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34357 if (!SWIG_IsOK(res1)) {
34358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34359 }
34360 arg1 = reinterpret_cast< wxWindow * >(argp1);
34361 {
34362 PyThreadState* __tstate = wxPyBeginAllowThreads();
34363 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34364 wxPyEndAllowThreads(__tstate);
34365 if (PyErr_Occurred()) SWIG_fail;
34366 }
34367 resultobj = SWIG_Py_Void();
34368 if (SWIG_IsTmpObj(res2)) {
34369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34370 } else {
34371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34373 }
34374 if (SWIG_IsTmpObj(res3)) {
34375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34376 } else {
34377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34379 }
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 wxPoint result;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 PyObject *swig_obj[1] ;
34393
34394 if (!args) SWIG_fail;
34395 swig_obj[0] = args;
34396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res1)) {
34398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 wxRect result;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = ((wxWindow const *)arg1)->GetClientRect();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 wxSize result;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 PyObject *swig_obj[1] ;
34449
34450 if (!args) SWIG_fail;
34451 swig_obj[0] = args;
34452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34453 if (!SWIG_IsOK(res1)) {
34454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34455 }
34456 arg1 = reinterpret_cast< wxWindow * >(argp1);
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 result = ((wxWindow const *)arg1)->GetBestSize();
34460 wxPyEndAllowThreads(__tstate);
34461 if (PyErr_Occurred()) SWIG_fail;
34462 }
34463 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34464 return resultobj;
34465 fail:
34466 return NULL;
34467 }
34468
34469
34470 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34471 PyObject *resultobj = 0;
34472 wxWindow *arg1 = (wxWindow *) 0 ;
34473 int *arg2 = (int *) 0 ;
34474 int *arg3 = (int *) 0 ;
34475 void *argp1 = 0 ;
34476 int res1 = 0 ;
34477 int temp2 ;
34478 int res2 = SWIG_TMPOBJ ;
34479 int temp3 ;
34480 int res3 = SWIG_TMPOBJ ;
34481 PyObject *swig_obj[1] ;
34482
34483 arg2 = &temp2;
34484 arg3 = &temp3;
34485 if (!args) SWIG_fail;
34486 swig_obj[0] = args;
34487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34490 }
34491 arg1 = reinterpret_cast< wxWindow * >(argp1);
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_Py_Void();
34499 if (SWIG_IsTmpObj(res2)) {
34500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34501 } else {
34502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34504 }
34505 if (SWIG_IsTmpObj(res3)) {
34506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34507 } else {
34508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 void *argp1 = 0 ;
34521 int res1 = 0 ;
34522 PyObject *swig_obj[1] ;
34523
34524 if (!args) SWIG_fail;
34525 swig_obj[0] = args;
34526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34527 if (!SWIG_IsOK(res1)) {
34528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34529 }
34530 arg1 = reinterpret_cast< wxWindow * >(argp1);
34531 {
34532 PyThreadState* __tstate = wxPyBeginAllowThreads();
34533 (arg1)->InvalidateBestSize();
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 resultobj = SWIG_Py_Void();
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34545 PyObject *resultobj = 0;
34546 wxWindow *arg1 = (wxWindow *) 0 ;
34547 wxSize *arg2 = 0 ;
34548 void *argp1 = 0 ;
34549 int res1 = 0 ;
34550 wxSize temp2 ;
34551 PyObject * obj0 = 0 ;
34552 PyObject * obj1 = 0 ;
34553 char * kwnames[] = {
34554 (char *) "self",(char *) "size", NULL
34555 };
34556
34557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34559 if (!SWIG_IsOK(res1)) {
34560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34561 }
34562 arg1 = reinterpret_cast< wxWindow * >(argp1);
34563 {
34564 arg2 = &temp2;
34565 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34566 }
34567 {
34568 PyThreadState* __tstate = wxPyBeginAllowThreads();
34569 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 resultobj = SWIG_Py_Void();
34574 return resultobj;
34575 fail:
34576 return NULL;
34577 }
34578
34579
34580 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34581 PyObject *resultobj = 0;
34582 wxWindow *arg1 = (wxWindow *) 0 ;
34583 wxSize result;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 PyObject *swig_obj[1] ;
34587
34588 if (!args) SWIG_fail;
34589 swig_obj[0] = args;
34590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34598 wxPyEndAllowThreads(__tstate);
34599 if (PyErr_Occurred()) SWIG_fail;
34600 }
34601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34602 return resultobj;
34603 fail:
34604 return NULL;
34605 }
34606
34607
34608 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34609 PyObject *resultobj = 0;
34610 wxWindow *arg1 = (wxWindow *) 0 ;
34611 int arg2 = (int) wxBOTH ;
34612 void *argp1 = 0 ;
34613 int res1 = 0 ;
34614 int val2 ;
34615 int ecode2 = 0 ;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 char * kwnames[] = {
34619 (char *) "self",(char *) "direction", NULL
34620 };
34621
34622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34624 if (!SWIG_IsOK(res1)) {
34625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34626 }
34627 arg1 = reinterpret_cast< wxWindow * >(argp1);
34628 if (obj1) {
34629 ecode2 = SWIG_AsVal_int(obj1, &val2);
34630 if (!SWIG_IsOK(ecode2)) {
34631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34632 }
34633 arg2 = static_cast< int >(val2);
34634 }
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 (arg1)->Center(arg2);
34638 wxPyEndAllowThreads(__tstate);
34639 if (PyErr_Occurred()) SWIG_fail;
34640 }
34641 resultobj = SWIG_Py_Void();
34642 return resultobj;
34643 fail:
34644 return NULL;
34645 }
34646
34647
34648 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34649 PyObject *resultobj = 0;
34650 wxWindow *arg1 = (wxWindow *) 0 ;
34651 int arg2 = (int) wxBOTH ;
34652 void *argp1 = 0 ;
34653 int res1 = 0 ;
34654 int val2 ;
34655 int ecode2 = 0 ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 char * kwnames[] = {
34659 (char *) "self",(char *) "dir", NULL
34660 };
34661
34662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34664 if (!SWIG_IsOK(res1)) {
34665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34666 }
34667 arg1 = reinterpret_cast< wxWindow * >(argp1);
34668 if (obj1) {
34669 ecode2 = SWIG_AsVal_int(obj1, &val2);
34670 if (!SWIG_IsOK(ecode2)) {
34671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34672 }
34673 arg2 = static_cast< int >(val2);
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 (arg1)->CenterOnParent(arg2);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 resultobj = SWIG_Py_Void();
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34689 PyObject *resultobj = 0;
34690 wxWindow *arg1 = (wxWindow *) 0 ;
34691 void *argp1 = 0 ;
34692 int res1 = 0 ;
34693 PyObject *swig_obj[1] ;
34694
34695 if (!args) SWIG_fail;
34696 swig_obj[0] = args;
34697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34698 if (!SWIG_IsOK(res1)) {
34699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34700 }
34701 arg1 = reinterpret_cast< wxWindow * >(argp1);
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 (arg1)->Fit();
34705 wxPyEndAllowThreads(__tstate);
34706 if (PyErr_Occurred()) SWIG_fail;
34707 }
34708 resultobj = SWIG_Py_Void();
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34716 PyObject *resultobj = 0;
34717 wxWindow *arg1 = (wxWindow *) 0 ;
34718 void *argp1 = 0 ;
34719 int res1 = 0 ;
34720 PyObject *swig_obj[1] ;
34721
34722 if (!args) SWIG_fail;
34723 swig_obj[0] = args;
34724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34725 if (!SWIG_IsOK(res1)) {
34726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34727 }
34728 arg1 = reinterpret_cast< wxWindow * >(argp1);
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 (arg1)->FitInside();
34732 wxPyEndAllowThreads(__tstate);
34733 if (PyErr_Occurred()) SWIG_fail;
34734 }
34735 resultobj = SWIG_Py_Void();
34736 return resultobj;
34737 fail:
34738 return NULL;
34739 }
34740
34741
34742 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34743 PyObject *resultobj = 0;
34744 wxWindow *arg1 = (wxWindow *) 0 ;
34745 int arg2 ;
34746 int arg3 ;
34747 int arg4 = (int) -1 ;
34748 int arg5 = (int) -1 ;
34749 int arg6 = (int) -1 ;
34750 int arg7 = (int) -1 ;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 int val2 ;
34754 int ecode2 = 0 ;
34755 int val3 ;
34756 int ecode3 = 0 ;
34757 int val4 ;
34758 int ecode4 = 0 ;
34759 int val5 ;
34760 int ecode5 = 0 ;
34761 int val6 ;
34762 int ecode6 = 0 ;
34763 int val7 ;
34764 int ecode7 = 0 ;
34765 PyObject * obj0 = 0 ;
34766 PyObject * obj1 = 0 ;
34767 PyObject * obj2 = 0 ;
34768 PyObject * obj3 = 0 ;
34769 PyObject * obj4 = 0 ;
34770 PyObject * obj5 = 0 ;
34771 PyObject * obj6 = 0 ;
34772 char * kwnames[] = {
34773 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34774 };
34775
34776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34778 if (!SWIG_IsOK(res1)) {
34779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34780 }
34781 arg1 = reinterpret_cast< wxWindow * >(argp1);
34782 ecode2 = SWIG_AsVal_int(obj1, &val2);
34783 if (!SWIG_IsOK(ecode2)) {
34784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34785 }
34786 arg2 = static_cast< int >(val2);
34787 ecode3 = SWIG_AsVal_int(obj2, &val3);
34788 if (!SWIG_IsOK(ecode3)) {
34789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34790 }
34791 arg3 = static_cast< int >(val3);
34792 if (obj3) {
34793 ecode4 = SWIG_AsVal_int(obj3, &val4);
34794 if (!SWIG_IsOK(ecode4)) {
34795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34796 }
34797 arg4 = static_cast< int >(val4);
34798 }
34799 if (obj4) {
34800 ecode5 = SWIG_AsVal_int(obj4, &val5);
34801 if (!SWIG_IsOK(ecode5)) {
34802 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34803 }
34804 arg5 = static_cast< int >(val5);
34805 }
34806 if (obj5) {
34807 ecode6 = SWIG_AsVal_int(obj5, &val6);
34808 if (!SWIG_IsOK(ecode6)) {
34809 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34810 }
34811 arg6 = static_cast< int >(val6);
34812 }
34813 if (obj6) {
34814 ecode7 = SWIG_AsVal_int(obj6, &val7);
34815 if (!SWIG_IsOK(ecode7)) {
34816 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34817 }
34818 arg7 = static_cast< int >(val7);
34819 }
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 resultobj = SWIG_Py_Void();
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 wxSize *arg2 = 0 ;
34837 wxSize const &arg3_defvalue = wxDefaultSize ;
34838 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34839 wxSize const &arg4_defvalue = wxDefaultSize ;
34840 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34841 void *argp1 = 0 ;
34842 int res1 = 0 ;
34843 wxSize temp2 ;
34844 wxSize temp3 ;
34845 wxSize temp4 ;
34846 PyObject * obj0 = 0 ;
34847 PyObject * obj1 = 0 ;
34848 PyObject * obj2 = 0 ;
34849 PyObject * obj3 = 0 ;
34850 char * kwnames[] = {
34851 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34852 };
34853
34854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34856 if (!SWIG_IsOK(res1)) {
34857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34858 }
34859 arg1 = reinterpret_cast< wxWindow * >(argp1);
34860 {
34861 arg2 = &temp2;
34862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34863 }
34864 if (obj2) {
34865 {
34866 arg3 = &temp3;
34867 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34868 }
34869 }
34870 if (obj3) {
34871 {
34872 arg4 = &temp4;
34873 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34874 }
34875 }
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 resultobj = SWIG_Py_Void();
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34890 PyObject *resultobj = 0;
34891 wxWindow *arg1 = (wxWindow *) 0 ;
34892 int arg2 ;
34893 int arg3 ;
34894 int arg4 = (int) -1 ;
34895 int arg5 = (int) -1 ;
34896 void *argp1 = 0 ;
34897 int res1 = 0 ;
34898 int val2 ;
34899 int ecode2 = 0 ;
34900 int val3 ;
34901 int ecode3 = 0 ;
34902 int val4 ;
34903 int ecode4 = 0 ;
34904 int val5 ;
34905 int ecode5 = 0 ;
34906 PyObject * obj0 = 0 ;
34907 PyObject * obj1 = 0 ;
34908 PyObject * obj2 = 0 ;
34909 PyObject * obj3 = 0 ;
34910 PyObject * obj4 = 0 ;
34911 char * kwnames[] = {
34912 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34913 };
34914
34915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34917 if (!SWIG_IsOK(res1)) {
34918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 ecode2 = SWIG_AsVal_int(obj1, &val2);
34922 if (!SWIG_IsOK(ecode2)) {
34923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34924 }
34925 arg2 = static_cast< int >(val2);
34926 ecode3 = SWIG_AsVal_int(obj2, &val3);
34927 if (!SWIG_IsOK(ecode3)) {
34928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34929 }
34930 arg3 = static_cast< int >(val3);
34931 if (obj3) {
34932 ecode4 = SWIG_AsVal_int(obj3, &val4);
34933 if (!SWIG_IsOK(ecode4)) {
34934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34935 }
34936 arg4 = static_cast< int >(val4);
34937 }
34938 if (obj4) {
34939 ecode5 = SWIG_AsVal_int(obj4, &val5);
34940 if (!SWIG_IsOK(ecode5)) {
34941 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34942 }
34943 arg5 = static_cast< int >(val5);
34944 }
34945 {
34946 PyThreadState* __tstate = wxPyBeginAllowThreads();
34947 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 resultobj = SWIG_Py_Void();
34952 return resultobj;
34953 fail:
34954 return NULL;
34955 }
34956
34957
34958 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34959 PyObject *resultobj = 0;
34960 wxWindow *arg1 = (wxWindow *) 0 ;
34961 wxSize *arg2 = 0 ;
34962 wxSize const &arg3_defvalue = wxDefaultSize ;
34963 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34964 void *argp1 = 0 ;
34965 int res1 = 0 ;
34966 wxSize temp2 ;
34967 wxSize temp3 ;
34968 PyObject * obj0 = 0 ;
34969 PyObject * obj1 = 0 ;
34970 PyObject * obj2 = 0 ;
34971 char * kwnames[] = {
34972 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34973 };
34974
34975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34977 if (!SWIG_IsOK(res1)) {
34978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34979 }
34980 arg1 = reinterpret_cast< wxWindow * >(argp1);
34981 {
34982 arg2 = &temp2;
34983 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34984 }
34985 if (obj2) {
34986 {
34987 arg3 = &temp3;
34988 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34989 }
34990 }
34991 {
34992 PyThreadState* __tstate = wxPyBeginAllowThreads();
34993 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34994 wxPyEndAllowThreads(__tstate);
34995 if (PyErr_Occurred()) SWIG_fail;
34996 }
34997 resultobj = SWIG_Py_Void();
34998 return resultobj;
34999 fail:
35000 return NULL;
35001 }
35002
35003
35004 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35005 PyObject *resultobj = 0;
35006 wxWindow *arg1 = (wxWindow *) 0 ;
35007 wxSize result;
35008 void *argp1 = 0 ;
35009 int res1 = 0 ;
35010 PyObject *swig_obj[1] ;
35011
35012 if (!args) SWIG_fail;
35013 swig_obj[0] = args;
35014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 result = ((wxWindow const *)arg1)->GetMaxSize();
35022 wxPyEndAllowThreads(__tstate);
35023 if (PyErr_Occurred()) SWIG_fail;
35024 }
35025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35026 return resultobj;
35027 fail:
35028 return NULL;
35029 }
35030
35031
35032 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35033 PyObject *resultobj = 0;
35034 wxWindow *arg1 = (wxWindow *) 0 ;
35035 wxSize result;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 PyObject *swig_obj[1] ;
35039
35040 if (!args) SWIG_fail;
35041 swig_obj[0] = args;
35042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35043 if (!SWIG_IsOK(res1)) {
35044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35045 }
35046 arg1 = reinterpret_cast< wxWindow * >(argp1);
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 result = ((wxWindow const *)arg1)->GetMinSize();
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxWindow *arg1 = (wxWindow *) 0 ;
35063 wxSize *arg2 = 0 ;
35064 void *argp1 = 0 ;
35065 int res1 = 0 ;
35066 wxSize temp2 ;
35067 PyObject * obj0 = 0 ;
35068 PyObject * obj1 = 0 ;
35069 char * kwnames[] = {
35070 (char *) "self",(char *) "minSize", NULL
35071 };
35072
35073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35075 if (!SWIG_IsOK(res1)) {
35076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35077 }
35078 arg1 = reinterpret_cast< wxWindow * >(argp1);
35079 {
35080 arg2 = &temp2;
35081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35082 }
35083 {
35084 PyThreadState* __tstate = wxPyBeginAllowThreads();
35085 (arg1)->SetMinSize((wxSize const &)*arg2);
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 resultobj = SWIG_Py_Void();
35090 return resultobj;
35091 fail:
35092 return NULL;
35093 }
35094
35095
35096 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35097 PyObject *resultobj = 0;
35098 wxWindow *arg1 = (wxWindow *) 0 ;
35099 wxSize *arg2 = 0 ;
35100 void *argp1 = 0 ;
35101 int res1 = 0 ;
35102 wxSize temp2 ;
35103 PyObject * obj0 = 0 ;
35104 PyObject * obj1 = 0 ;
35105 char * kwnames[] = {
35106 (char *) "self",(char *) "maxSize", NULL
35107 };
35108
35109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 arg2 = &temp2;
35117 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35118 }
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 (arg1)->SetMaxSize((wxSize const &)*arg2);
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 resultobj = SWIG_Py_Void();
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35133 PyObject *resultobj = 0;
35134 wxWindow *arg1 = (wxWindow *) 0 ;
35135 int result;
35136 void *argp1 = 0 ;
35137 int res1 = 0 ;
35138 PyObject *swig_obj[1] ;
35139
35140 if (!args) SWIG_fail;
35141 swig_obj[0] = args;
35142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35143 if (!SWIG_IsOK(res1)) {
35144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35145 }
35146 arg1 = reinterpret_cast< wxWindow * >(argp1);
35147 {
35148 PyThreadState* __tstate = wxPyBeginAllowThreads();
35149 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35150 wxPyEndAllowThreads(__tstate);
35151 if (PyErr_Occurred()) SWIG_fail;
35152 }
35153 resultobj = SWIG_From_int(static_cast< int >(result));
35154 return resultobj;
35155 fail:
35156 return NULL;
35157 }
35158
35159
35160 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35161 PyObject *resultobj = 0;
35162 wxWindow *arg1 = (wxWindow *) 0 ;
35163 int result;
35164 void *argp1 = 0 ;
35165 int res1 = 0 ;
35166 PyObject *swig_obj[1] ;
35167
35168 if (!args) SWIG_fail;
35169 swig_obj[0] = args;
35170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35171 if (!SWIG_IsOK(res1)) {
35172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35173 }
35174 arg1 = reinterpret_cast< wxWindow * >(argp1);
35175 {
35176 PyThreadState* __tstate = wxPyBeginAllowThreads();
35177 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35178 wxPyEndAllowThreads(__tstate);
35179 if (PyErr_Occurred()) SWIG_fail;
35180 }
35181 resultobj = SWIG_From_int(static_cast< int >(result));
35182 return resultobj;
35183 fail:
35184 return NULL;
35185 }
35186
35187
35188 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35189 PyObject *resultobj = 0;
35190 wxWindow *arg1 = (wxWindow *) 0 ;
35191 int result;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 PyObject *swig_obj[1] ;
35195
35196 if (!args) SWIG_fail;
35197 swig_obj[0] = args;
35198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35199 if (!SWIG_IsOK(res1)) {
35200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35201 }
35202 arg1 = reinterpret_cast< wxWindow * >(argp1);
35203 {
35204 PyThreadState* __tstate = wxPyBeginAllowThreads();
35205 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 resultobj = SWIG_From_int(static_cast< int >(result));
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35217 PyObject *resultobj = 0;
35218 wxWindow *arg1 = (wxWindow *) 0 ;
35219 int result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 PyObject *swig_obj[1] ;
35223
35224 if (!args) SWIG_fail;
35225 swig_obj[0] = args;
35226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35227 if (!SWIG_IsOK(res1)) {
35228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35229 }
35230 arg1 = reinterpret_cast< wxWindow * >(argp1);
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 resultobj = SWIG_From_int(static_cast< int >(result));
35238 return resultobj;
35239 fail:
35240 return NULL;
35241 }
35242
35243
35244 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35245 PyObject *resultobj = 0;
35246 wxWindow *arg1 = (wxWindow *) 0 ;
35247 wxSize *arg2 = 0 ;
35248 void *argp1 = 0 ;
35249 int res1 = 0 ;
35250 wxSize temp2 ;
35251 PyObject * obj0 = 0 ;
35252 PyObject * obj1 = 0 ;
35253 char * kwnames[] = {
35254 (char *) "self",(char *) "size", NULL
35255 };
35256
35257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35261 }
35262 arg1 = reinterpret_cast< wxWindow * >(argp1);
35263 {
35264 arg2 = &temp2;
35265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35266 }
35267 {
35268 PyThreadState* __tstate = wxPyBeginAllowThreads();
35269 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35270 wxPyEndAllowThreads(__tstate);
35271 if (PyErr_Occurred()) SWIG_fail;
35272 }
35273 resultobj = SWIG_Py_Void();
35274 return resultobj;
35275 fail:
35276 return NULL;
35277 }
35278
35279
35280 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35281 PyObject *resultobj = 0;
35282 wxWindow *arg1 = (wxWindow *) 0 ;
35283 int arg2 ;
35284 int arg3 ;
35285 void *argp1 = 0 ;
35286 int res1 = 0 ;
35287 int val2 ;
35288 int ecode2 = 0 ;
35289 int val3 ;
35290 int ecode3 = 0 ;
35291 PyObject * obj0 = 0 ;
35292 PyObject * obj1 = 0 ;
35293 PyObject * obj2 = 0 ;
35294 char * kwnames[] = {
35295 (char *) "self",(char *) "w",(char *) "h", NULL
35296 };
35297
35298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35300 if (!SWIG_IsOK(res1)) {
35301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35302 }
35303 arg1 = reinterpret_cast< wxWindow * >(argp1);
35304 ecode2 = SWIG_AsVal_int(obj1, &val2);
35305 if (!SWIG_IsOK(ecode2)) {
35306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35307 }
35308 arg2 = static_cast< int >(val2);
35309 ecode3 = SWIG_AsVal_int(obj2, &val3);
35310 if (!SWIG_IsOK(ecode3)) {
35311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35312 }
35313 arg3 = static_cast< int >(val3);
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 (arg1)->SetVirtualSize(arg2,arg3);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 resultobj = SWIG_Py_Void();
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35328 PyObject *resultobj = 0;
35329 wxWindow *arg1 = (wxWindow *) 0 ;
35330 wxSize result;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 PyObject *swig_obj[1] ;
35334
35335 if (!args) SWIG_fail;
35336 swig_obj[0] = args;
35337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35338 if (!SWIG_IsOK(res1)) {
35339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35340 }
35341 arg1 = reinterpret_cast< wxWindow * >(argp1);
35342 {
35343 PyThreadState* __tstate = wxPyBeginAllowThreads();
35344 result = ((wxWindow const *)arg1)->GetVirtualSize();
35345 wxPyEndAllowThreads(__tstate);
35346 if (PyErr_Occurred()) SWIG_fail;
35347 }
35348 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35356 PyObject *resultobj = 0;
35357 wxWindow *arg1 = (wxWindow *) 0 ;
35358 int *arg2 = (int *) 0 ;
35359 int *arg3 = (int *) 0 ;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 int temp2 ;
35363 int res2 = SWIG_TMPOBJ ;
35364 int temp3 ;
35365 int res3 = SWIG_TMPOBJ ;
35366 PyObject *swig_obj[1] ;
35367
35368 arg2 = &temp2;
35369 arg3 = &temp3;
35370 if (!args) SWIG_fail;
35371 swig_obj[0] = args;
35372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35373 if (!SWIG_IsOK(res1)) {
35374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35375 }
35376 arg1 = reinterpret_cast< wxWindow * >(argp1);
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35380 wxPyEndAllowThreads(__tstate);
35381 if (PyErr_Occurred()) SWIG_fail;
35382 }
35383 resultobj = SWIG_Py_Void();
35384 if (SWIG_IsTmpObj(res2)) {
35385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35386 } else {
35387 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35389 }
35390 if (SWIG_IsTmpObj(res3)) {
35391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35392 } else {
35393 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35395 }
35396 return resultobj;
35397 fail:
35398 return NULL;
35399 }
35400
35401
35402 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35403 PyObject *resultobj = 0;
35404 wxWindow *arg1 = (wxWindow *) 0 ;
35405 wxSize result;
35406 void *argp1 = 0 ;
35407 int res1 = 0 ;
35408 PyObject *swig_obj[1] ;
35409
35410 if (!args) SWIG_fail;
35411 swig_obj[0] = args;
35412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35413 if (!SWIG_IsOK(res1)) {
35414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35415 }
35416 arg1 = reinterpret_cast< wxWindow * >(argp1);
35417 {
35418 PyThreadState* __tstate = wxPyBeginAllowThreads();
35419 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35424 return resultobj;
35425 fail:
35426 return NULL;
35427 }
35428
35429
35430 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35431 PyObject *resultobj = 0;
35432 wxWindow *arg1 = (wxWindow *) 0 ;
35433 wxSize result;
35434 void *argp1 = 0 ;
35435 int res1 = 0 ;
35436 PyObject *swig_obj[1] ;
35437
35438 if (!args) SWIG_fail;
35439 swig_obj[0] = args;
35440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35441 if (!SWIG_IsOK(res1)) {
35442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35443 }
35444 arg1 = reinterpret_cast< wxWindow * >(argp1);
35445 {
35446 PyThreadState* __tstate = wxPyBeginAllowThreads();
35447 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj = 0;
35460 wxWindow *arg1 = (wxWindow *) 0 ;
35461 bool arg2 = (bool) true ;
35462 bool result;
35463 void *argp1 = 0 ;
35464 int res1 = 0 ;
35465 bool val2 ;
35466 int ecode2 = 0 ;
35467 PyObject * obj0 = 0 ;
35468 PyObject * obj1 = 0 ;
35469 char * kwnames[] = {
35470 (char *) "self",(char *) "show", NULL
35471 };
35472
35473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35475 if (!SWIG_IsOK(res1)) {
35476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35477 }
35478 arg1 = reinterpret_cast< wxWindow * >(argp1);
35479 if (obj1) {
35480 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35481 if (!SWIG_IsOK(ecode2)) {
35482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35483 }
35484 arg2 = static_cast< bool >(val2);
35485 }
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = (bool)(arg1)->Show(arg2);
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 {
35493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35494 }
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 bool result;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 PyObject *swig_obj[1] ;
35508
35509 if (!args) SWIG_fail;
35510 swig_obj[0] = args;
35511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35512 if (!SWIG_IsOK(res1)) {
35513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35514 }
35515 arg1 = reinterpret_cast< wxWindow * >(argp1);
35516 {
35517 PyThreadState* __tstate = wxPyBeginAllowThreads();
35518 result = (bool)(arg1)->Hide();
35519 wxPyEndAllowThreads(__tstate);
35520 if (PyErr_Occurred()) SWIG_fail;
35521 }
35522 {
35523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj = 0;
35533 wxWindow *arg1 = (wxWindow *) 0 ;
35534 bool arg2 = (bool) true ;
35535 bool result;
35536 void *argp1 = 0 ;
35537 int res1 = 0 ;
35538 bool val2 ;
35539 int ecode2 = 0 ;
35540 PyObject * obj0 = 0 ;
35541 PyObject * obj1 = 0 ;
35542 char * kwnames[] = {
35543 (char *) "self",(char *) "enable", NULL
35544 };
35545
35546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35548 if (!SWIG_IsOK(res1)) {
35549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35550 }
35551 arg1 = reinterpret_cast< wxWindow * >(argp1);
35552 if (obj1) {
35553 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35554 if (!SWIG_IsOK(ecode2)) {
35555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35556 }
35557 arg2 = static_cast< bool >(val2);
35558 }
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 result = (bool)(arg1)->Enable(arg2);
35562 wxPyEndAllowThreads(__tstate);
35563 if (PyErr_Occurred()) SWIG_fail;
35564 }
35565 {
35566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35567 }
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35575 PyObject *resultobj = 0;
35576 wxWindow *arg1 = (wxWindow *) 0 ;
35577 bool result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 PyObject *swig_obj[1] ;
35581
35582 if (!args) SWIG_fail;
35583 swig_obj[0] = args;
35584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35585 if (!SWIG_IsOK(res1)) {
35586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35587 }
35588 arg1 = reinterpret_cast< wxWindow * >(argp1);
35589 {
35590 PyThreadState* __tstate = wxPyBeginAllowThreads();
35591 result = (bool)(arg1)->Disable();
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 {
35596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35597 }
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35605 PyObject *resultobj = 0;
35606 wxWindow *arg1 = (wxWindow *) 0 ;
35607 bool result;
35608 void *argp1 = 0 ;
35609 int res1 = 0 ;
35610 PyObject *swig_obj[1] ;
35611
35612 if (!args) SWIG_fail;
35613 swig_obj[0] = args;
35614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35615 if (!SWIG_IsOK(res1)) {
35616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35617 }
35618 arg1 = reinterpret_cast< wxWindow * >(argp1);
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 result = (bool)((wxWindow const *)arg1)->IsShown();
35622 wxPyEndAllowThreads(__tstate);
35623 if (PyErr_Occurred()) SWIG_fail;
35624 }
35625 {
35626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35627 }
35628 return resultobj;
35629 fail:
35630 return NULL;
35631 }
35632
35633
35634 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35635 PyObject *resultobj = 0;
35636 wxWindow *arg1 = (wxWindow *) 0 ;
35637 bool result;
35638 void *argp1 = 0 ;
35639 int res1 = 0 ;
35640 PyObject *swig_obj[1] ;
35641
35642 if (!args) SWIG_fail;
35643 swig_obj[0] = args;
35644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35645 if (!SWIG_IsOK(res1)) {
35646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35647 }
35648 arg1 = reinterpret_cast< wxWindow * >(argp1);
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 {
35656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35657 }
35658 return resultobj;
35659 fail:
35660 return NULL;
35661 }
35662
35663
35664 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35665 PyObject *resultobj = 0;
35666 wxWindow *arg1 = (wxWindow *) 0 ;
35667 bool result;
35668 void *argp1 = 0 ;
35669 int res1 = 0 ;
35670 PyObject *swig_obj[1] ;
35671
35672 if (!args) SWIG_fail;
35673 swig_obj[0] = args;
35674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35675 if (!SWIG_IsOK(res1)) {
35676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35677 }
35678 arg1 = reinterpret_cast< wxWindow * >(argp1);
35679 {
35680 PyThreadState* __tstate = wxPyBeginAllowThreads();
35681 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35682 wxPyEndAllowThreads(__tstate);
35683 if (PyErr_Occurred()) SWIG_fail;
35684 }
35685 {
35686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35687 }
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35695 PyObject *resultobj = 0;
35696 wxWindow *arg1 = (wxWindow *) 0 ;
35697 long arg2 ;
35698 void *argp1 = 0 ;
35699 int res1 = 0 ;
35700 long val2 ;
35701 int ecode2 = 0 ;
35702 PyObject * obj0 = 0 ;
35703 PyObject * obj1 = 0 ;
35704 char * kwnames[] = {
35705 (char *) "self",(char *) "style", NULL
35706 };
35707
35708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35710 if (!SWIG_IsOK(res1)) {
35711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35712 }
35713 arg1 = reinterpret_cast< wxWindow * >(argp1);
35714 ecode2 = SWIG_AsVal_long(obj1, &val2);
35715 if (!SWIG_IsOK(ecode2)) {
35716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35717 }
35718 arg2 = static_cast< long >(val2);
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 (arg1)->SetWindowStyleFlag(arg2);
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 resultobj = SWIG_Py_Void();
35726 return resultobj;
35727 fail:
35728 return NULL;
35729 }
35730
35731
35732 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35733 PyObject *resultobj = 0;
35734 wxWindow *arg1 = (wxWindow *) 0 ;
35735 long result;
35736 void *argp1 = 0 ;
35737 int res1 = 0 ;
35738 PyObject *swig_obj[1] ;
35739
35740 if (!args) SWIG_fail;
35741 swig_obj[0] = args;
35742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35743 if (!SWIG_IsOK(res1)) {
35744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35745 }
35746 arg1 = reinterpret_cast< wxWindow * >(argp1);
35747 {
35748 PyThreadState* __tstate = wxPyBeginAllowThreads();
35749 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 resultobj = SWIG_From_long(static_cast< long >(result));
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35761 PyObject *resultobj = 0;
35762 wxWindow *arg1 = (wxWindow *) 0 ;
35763 int arg2 ;
35764 bool result;
35765 void *argp1 = 0 ;
35766 int res1 = 0 ;
35767 int val2 ;
35768 int ecode2 = 0 ;
35769 PyObject * obj0 = 0 ;
35770 PyObject * obj1 = 0 ;
35771 char * kwnames[] = {
35772 (char *) "self",(char *) "flag", NULL
35773 };
35774
35775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35777 if (!SWIG_IsOK(res1)) {
35778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35779 }
35780 arg1 = reinterpret_cast< wxWindow * >(argp1);
35781 ecode2 = SWIG_AsVal_int(obj1, &val2);
35782 if (!SWIG_IsOK(ecode2)) {
35783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35784 }
35785 arg2 = static_cast< int >(val2);
35786 {
35787 PyThreadState* __tstate = wxPyBeginAllowThreads();
35788 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 {
35793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35794 }
35795 return resultobj;
35796 fail:
35797 return NULL;
35798 }
35799
35800
35801 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35802 PyObject *resultobj = 0;
35803 wxWindow *arg1 = (wxWindow *) 0 ;
35804 bool result;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 PyObject *swig_obj[1] ;
35808
35809 if (!args) SWIG_fail;
35810 swig_obj[0] = args;
35811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35814 }
35815 arg1 = reinterpret_cast< wxWindow * >(argp1);
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 result = (bool)((wxWindow const *)arg1)->IsRetained();
35819 wxPyEndAllowThreads(__tstate);
35820 if (PyErr_Occurred()) SWIG_fail;
35821 }
35822 {
35823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35824 }
35825 return resultobj;
35826 fail:
35827 return NULL;
35828 }
35829
35830
35831 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35832 PyObject *resultobj = 0;
35833 wxWindow *arg1 = (wxWindow *) 0 ;
35834 int arg2 ;
35835 bool result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 int val2 ;
35839 int ecode2 = 0 ;
35840 PyObject * obj0 = 0 ;
35841 PyObject * obj1 = 0 ;
35842 char * kwnames[] = {
35843 (char *) "self",(char *) "flag", NULL
35844 };
35845
35846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35848 if (!SWIG_IsOK(res1)) {
35849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35850 }
35851 arg1 = reinterpret_cast< wxWindow * >(argp1);
35852 ecode2 = SWIG_AsVal_int(obj1, &val2);
35853 if (!SWIG_IsOK(ecode2)) {
35854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
35855 }
35856 arg2 = static_cast< int >(val2);
35857 {
35858 PyThreadState* __tstate = wxPyBeginAllowThreads();
35859 result = (bool)(arg1)->ToggleWindowStyle(arg2);
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 {
35864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35865 }
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj = 0;
35874 wxWindow *arg1 = (wxWindow *) 0 ;
35875 long arg2 ;
35876 void *argp1 = 0 ;
35877 int res1 = 0 ;
35878 long val2 ;
35879 int ecode2 = 0 ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char * kwnames[] = {
35883 (char *) "self",(char *) "exStyle", NULL
35884 };
35885
35886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35890 }
35891 arg1 = reinterpret_cast< wxWindow * >(argp1);
35892 ecode2 = SWIG_AsVal_long(obj1, &val2);
35893 if (!SWIG_IsOK(ecode2)) {
35894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35895 }
35896 arg2 = static_cast< long >(val2);
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->SetExtraStyle(arg2);
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 resultobj = SWIG_Py_Void();
35904 return resultobj;
35905 fail:
35906 return NULL;
35907 }
35908
35909
35910 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35911 PyObject *resultobj = 0;
35912 wxWindow *arg1 = (wxWindow *) 0 ;
35913 long result;
35914 void *argp1 = 0 ;
35915 int res1 = 0 ;
35916 PyObject *swig_obj[1] ;
35917
35918 if (!args) SWIG_fail;
35919 swig_obj[0] = args;
35920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_From_long(static_cast< long >(result));
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 bool arg2 = (bool) true ;
35942 void *argp1 = 0 ;
35943 int res1 = 0 ;
35944 bool val2 ;
35945 int ecode2 = 0 ;
35946 PyObject * obj0 = 0 ;
35947 PyObject * obj1 = 0 ;
35948 char * kwnames[] = {
35949 (char *) "self",(char *) "modal", NULL
35950 };
35951
35952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35954 if (!SWIG_IsOK(res1)) {
35955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35956 }
35957 arg1 = reinterpret_cast< wxWindow * >(argp1);
35958 if (obj1) {
35959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35960 if (!SWIG_IsOK(ecode2)) {
35961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35962 }
35963 arg2 = static_cast< bool >(val2);
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 (arg1)->MakeModal(arg2);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_Py_Void();
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 bool arg2 ;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 bool val2 ;
35985 int ecode2 = 0 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 char * kwnames[] = {
35989 (char *) "self",(char *) "enableTheme", NULL
35990 };
35991
35992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35994 if (!SWIG_IsOK(res1)) {
35995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35996 }
35997 arg1 = reinterpret_cast< wxWindow * >(argp1);
35998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35999 if (!SWIG_IsOK(ecode2)) {
36000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36001 }
36002 arg2 = static_cast< bool >(val2);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 (arg1)->SetThemeEnabled(arg2);
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 resultobj = SWIG_Py_Void();
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 bool result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 PyObject *swig_obj[1] ;
36023
36024 if (!args) SWIG_fail;
36025 swig_obj[0] = args;
36026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 {
36038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36039 }
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxWindow *arg1 = (wxWindow *) 0 ;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 PyObject *swig_obj[1] ;
36052
36053 if (!args) SWIG_fail;
36054 swig_obj[0] = args;
36055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36056 if (!SWIG_IsOK(res1)) {
36057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36058 }
36059 arg1 = reinterpret_cast< wxWindow * >(argp1);
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 (arg1)->SetFocus();
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 resultobj = SWIG_Py_Void();
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36074 PyObject *resultobj = 0;
36075 wxWindow *arg1 = (wxWindow *) 0 ;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 PyObject *swig_obj[1] ;
36079
36080 if (!args) SWIG_fail;
36081 swig_obj[0] = args;
36082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36085 }
36086 arg1 = reinterpret_cast< wxWindow * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 (arg1)->SetFocusFromKbd();
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_Py_Void();
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36101 PyObject *resultobj = 0;
36102 wxWindow *result = 0 ;
36103
36104 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36105 {
36106 if (!wxPyCheckForApp()) SWIG_fail;
36107 PyThreadState* __tstate = wxPyBeginAllowThreads();
36108 result = (wxWindow *)wxWindow::FindFocus();
36109 wxPyEndAllowThreads(__tstate);
36110 if (PyErr_Occurred()) SWIG_fail;
36111 }
36112 {
36113 resultobj = wxPyMake_wxObject(result, 0);
36114 }
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36122 PyObject *resultobj = 0;
36123 wxWindow *arg1 = (wxWindow *) 0 ;
36124 bool result;
36125 void *argp1 = 0 ;
36126 int res1 = 0 ;
36127 PyObject *swig_obj[1] ;
36128
36129 if (!args) SWIG_fail;
36130 swig_obj[0] = args;
36131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36132 if (!SWIG_IsOK(res1)) {
36133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36134 }
36135 arg1 = reinterpret_cast< wxWindow * >(argp1);
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 {
36143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36144 }
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36152 PyObject *resultobj = 0;
36153 wxWindow *arg1 = (wxWindow *) 0 ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 PyObject *swig_obj[1] ;
36158
36159 if (!args) SWIG_fail;
36160 swig_obj[0] = args;
36161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36164 }
36165 arg1 = reinterpret_cast< wxWindow * >(argp1);
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 {
36173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36174 }
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36182 PyObject *resultobj = 0;
36183 wxWindow *arg1 = (wxWindow *) 0 ;
36184 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36185 bool result;
36186 void *argp1 = 0 ;
36187 int res1 = 0 ;
36188 int val2 ;
36189 int ecode2 = 0 ;
36190 PyObject * obj0 = 0 ;
36191 PyObject * obj1 = 0 ;
36192 char * kwnames[] = {
36193 (char *) "self",(char *) "flags", NULL
36194 };
36195
36196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36198 if (!SWIG_IsOK(res1)) {
36199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36200 }
36201 arg1 = reinterpret_cast< wxWindow * >(argp1);
36202 if (obj1) {
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 }
36209 {
36210 PyThreadState* __tstate = wxPyBeginAllowThreads();
36211 result = (bool)(arg1)->Navigate(arg2);
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 {
36216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36217 }
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj = 0;
36226 wxWindow *arg1 = (wxWindow *) 0 ;
36227 wxWindow *arg2 = (wxWindow *) 0 ;
36228 void *argp1 = 0 ;
36229 int res1 = 0 ;
36230 void *argp2 = 0 ;
36231 int res2 = 0 ;
36232 PyObject * obj0 = 0 ;
36233 PyObject * obj1 = 0 ;
36234 char * kwnames[] = {
36235 (char *) "self",(char *) "win", NULL
36236 };
36237
36238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36240 if (!SWIG_IsOK(res1)) {
36241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36242 }
36243 arg1 = reinterpret_cast< wxWindow * >(argp1);
36244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36245 if (!SWIG_IsOK(res2)) {
36246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36247 }
36248 arg2 = reinterpret_cast< wxWindow * >(argp2);
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 (arg1)->MoveAfterInTabOrder(arg2);
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_Py_Void();
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 wxWindow *arg2 = (wxWindow *) 0 ;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 void *argp2 = 0 ;
36269 int res2 = 0 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 char * kwnames[] = {
36273 (char *) "self",(char *) "win", NULL
36274 };
36275
36276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36278 if (!SWIG_IsOK(res1)) {
36279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36280 }
36281 arg1 = reinterpret_cast< wxWindow * >(argp1);
36282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36283 if (!SWIG_IsOK(res2)) {
36284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36285 }
36286 arg2 = reinterpret_cast< wxWindow * >(argp2);
36287 {
36288 PyThreadState* __tstate = wxPyBeginAllowThreads();
36289 (arg1)->MoveBeforeInTabOrder(arg2);
36290 wxPyEndAllowThreads(__tstate);
36291 if (PyErr_Occurred()) SWIG_fail;
36292 }
36293 resultobj = SWIG_Py_Void();
36294 return resultobj;
36295 fail:
36296 return NULL;
36297 }
36298
36299
36300 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36301 PyObject *resultobj = 0;
36302 wxWindow *arg1 = (wxWindow *) 0 ;
36303 PyObject *result = 0 ;
36304 void *argp1 = 0 ;
36305 int res1 = 0 ;
36306 PyObject *swig_obj[1] ;
36307
36308 if (!args) SWIG_fail;
36309 swig_obj[0] = args;
36310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36311 if (!SWIG_IsOK(res1)) {
36312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36313 }
36314 arg1 = reinterpret_cast< wxWindow * >(argp1);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (PyObject *)wxWindow_GetChildren(arg1);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 resultobj = result;
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *resultobj = 0;
36330 wxWindow *arg1 = (wxWindow *) 0 ;
36331 wxWindow *result = 0 ;
36332 void *argp1 = 0 ;
36333 int res1 = 0 ;
36334 PyObject *swig_obj[1] ;
36335
36336 if (!args) SWIG_fail;
36337 swig_obj[0] = args;
36338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36341 }
36342 arg1 = reinterpret_cast< wxWindow * >(argp1);
36343 {
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 {
36350 resultobj = wxPyMake_wxObject(result, 0);
36351 }
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36359 PyObject *resultobj = 0;
36360 wxWindow *arg1 = (wxWindow *) 0 ;
36361 wxWindow *result = 0 ;
36362 void *argp1 = 0 ;
36363 int res1 = 0 ;
36364 PyObject *swig_obj[1] ;
36365
36366 if (!args) SWIG_fail;
36367 swig_obj[0] = args;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36371 }
36372 arg1 = reinterpret_cast< wxWindow * >(argp1);
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 {
36380 resultobj = wxPyMake_wxObject(result, 0);
36381 }
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36389 PyObject *resultobj = 0;
36390 wxWindow *arg1 = (wxWindow *) 0 ;
36391 bool result;
36392 void *argp1 = 0 ;
36393 int res1 = 0 ;
36394 PyObject *swig_obj[1] ;
36395
36396 if (!args) SWIG_fail;
36397 swig_obj[0] = args;
36398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36399 if (!SWIG_IsOK(res1)) {
36400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36401 }
36402 arg1 = reinterpret_cast< wxWindow * >(argp1);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 {
36410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36411 }
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 wxWindow *arg2 = (wxWindow *) 0 ;
36422 bool result;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 void *argp2 = 0 ;
36426 int res2 = 0 ;
36427 PyObject * obj0 = 0 ;
36428 PyObject * obj1 = 0 ;
36429 char * kwnames[] = {
36430 (char *) "self",(char *) "newParent", NULL
36431 };
36432
36433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36435 if (!SWIG_IsOK(res1)) {
36436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36437 }
36438 arg1 = reinterpret_cast< wxWindow * >(argp1);
36439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36440 if (!SWIG_IsOK(res2)) {
36441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36442 }
36443 arg2 = reinterpret_cast< wxWindow * >(argp2);
36444 {
36445 PyThreadState* __tstate = wxPyBeginAllowThreads();
36446 result = (bool)(arg1)->Reparent(arg2);
36447 wxPyEndAllowThreads(__tstate);
36448 if (PyErr_Occurred()) SWIG_fail;
36449 }
36450 {
36451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36452 }
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 wxWindow *arg2 = (wxWindow *) 0 ;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 void *argp2 = 0 ;
36466 int res2 = 0 ;
36467 PyObject * obj0 = 0 ;
36468 PyObject * obj1 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "self",(char *) "child", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36480 if (!SWIG_IsOK(res2)) {
36481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36482 }
36483 arg2 = reinterpret_cast< wxWindow * >(argp2);
36484 {
36485 PyThreadState* __tstate = wxPyBeginAllowThreads();
36486 (arg1)->AddChild(arg2);
36487 wxPyEndAllowThreads(__tstate);
36488 if (PyErr_Occurred()) SWIG_fail;
36489 }
36490 resultobj = SWIG_Py_Void();
36491 return resultobj;
36492 fail:
36493 return NULL;
36494 }
36495
36496
36497 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36498 PyObject *resultobj = 0;
36499 wxWindow *arg1 = (wxWindow *) 0 ;
36500 wxWindow *arg2 = (wxWindow *) 0 ;
36501 void *argp1 = 0 ;
36502 int res1 = 0 ;
36503 void *argp2 = 0 ;
36504 int res2 = 0 ;
36505 PyObject * obj0 = 0 ;
36506 PyObject * obj1 = 0 ;
36507 char * kwnames[] = {
36508 (char *) "self",(char *) "child", NULL
36509 };
36510
36511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36513 if (!SWIG_IsOK(res1)) {
36514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36515 }
36516 arg1 = reinterpret_cast< wxWindow * >(argp1);
36517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36518 if (!SWIG_IsOK(res2)) {
36519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36520 }
36521 arg2 = reinterpret_cast< wxWindow * >(argp2);
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 (arg1)->RemoveChild(arg2);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 resultobj = SWIG_Py_Void();
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj = 0;
36537 wxWindow *arg1 = (wxWindow *) 0 ;
36538 bool arg2 ;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 bool val2 ;
36542 int ecode2 = 0 ;
36543 PyObject * obj0 = 0 ;
36544 PyObject * obj1 = 0 ;
36545 char * kwnames[] = {
36546 (char *) "self",(char *) "on", NULL
36547 };
36548
36549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36551 if (!SWIG_IsOK(res1)) {
36552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36553 }
36554 arg1 = reinterpret_cast< wxWindow * >(argp1);
36555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36556 if (!SWIG_IsOK(ecode2)) {
36557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36558 }
36559 arg2 = static_cast< bool >(val2);
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 wxWindow_SetDoubleBuffered(arg1,arg2);
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_Py_Void();
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 long arg2 ;
36577 wxWindow *result = 0 ;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 long val2 ;
36581 int ecode2 = 0 ;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char * kwnames[] = {
36585 (char *) "self",(char *) "winid", NULL
36586 };
36587
36588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 ecode2 = SWIG_AsVal_long(obj1, &val2);
36595 if (!SWIG_IsOK(ecode2)) {
36596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36597 }
36598 arg2 = static_cast< long >(val2);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (wxWindow *)(arg1)->FindWindow(arg2);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 {
36606 resultobj = wxPyMake_wxObject(result, 0);
36607 }
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36615 PyObject *resultobj = 0;
36616 wxWindow *arg1 = (wxWindow *) 0 ;
36617 wxString *arg2 = 0 ;
36618 wxWindow *result = 0 ;
36619 void *argp1 = 0 ;
36620 int res1 = 0 ;
36621 bool temp2 = false ;
36622 PyObject * obj0 = 0 ;
36623 PyObject * obj1 = 0 ;
36624 char * kwnames[] = {
36625 (char *) "self",(char *) "name", NULL
36626 };
36627
36628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36630 if (!SWIG_IsOK(res1)) {
36631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36632 }
36633 arg1 = reinterpret_cast< wxWindow * >(argp1);
36634 {
36635 arg2 = wxString_in_helper(obj1);
36636 if (arg2 == NULL) SWIG_fail;
36637 temp2 = true;
36638 }
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 {
36646 resultobj = wxPyMake_wxObject(result, 0);
36647 }
36648 {
36649 if (temp2)
36650 delete arg2;
36651 }
36652 return resultobj;
36653 fail:
36654 {
36655 if (temp2)
36656 delete arg2;
36657 }
36658 return NULL;
36659 }
36660
36661
36662 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36663 PyObject *resultobj = 0;
36664 wxWindow *arg1 = (wxWindow *) 0 ;
36665 wxEvtHandler *result = 0 ;
36666 void *argp1 = 0 ;
36667 int res1 = 0 ;
36668 PyObject *swig_obj[1] ;
36669
36670 if (!args) SWIG_fail;
36671 swig_obj[0] = args;
36672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36673 if (!SWIG_IsOK(res1)) {
36674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36675 }
36676 arg1 = reinterpret_cast< wxWindow * >(argp1);
36677 {
36678 PyThreadState* __tstate = wxPyBeginAllowThreads();
36679 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 {
36684 resultobj = wxPyMake_wxObject(result, 0);
36685 }
36686 return resultobj;
36687 fail:
36688 return NULL;
36689 }
36690
36691
36692 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36693 PyObject *resultobj = 0;
36694 wxWindow *arg1 = (wxWindow *) 0 ;
36695 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36696 void *argp1 = 0 ;
36697 int res1 = 0 ;
36698 void *argp2 = 0 ;
36699 int res2 = 0 ;
36700 PyObject * obj0 = 0 ;
36701 PyObject * obj1 = 0 ;
36702 char * kwnames[] = {
36703 (char *) "self",(char *) "handler", NULL
36704 };
36705
36706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36708 if (!SWIG_IsOK(res1)) {
36709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36710 }
36711 arg1 = reinterpret_cast< wxWindow * >(argp1);
36712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36713 if (!SWIG_IsOK(res2)) {
36714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36715 }
36716 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 (arg1)->SetEventHandler(arg2);
36720 wxPyEndAllowThreads(__tstate);
36721 if (PyErr_Occurred()) SWIG_fail;
36722 }
36723 resultobj = SWIG_Py_Void();
36724 return resultobj;
36725 fail:
36726 return NULL;
36727 }
36728
36729
36730 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36731 PyObject *resultobj = 0;
36732 wxWindow *arg1 = (wxWindow *) 0 ;
36733 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36734 void *argp1 = 0 ;
36735 int res1 = 0 ;
36736 void *argp2 = 0 ;
36737 int res2 = 0 ;
36738 PyObject * obj0 = 0 ;
36739 PyObject * obj1 = 0 ;
36740 char * kwnames[] = {
36741 (char *) "self",(char *) "handler", NULL
36742 };
36743
36744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36748 }
36749 arg1 = reinterpret_cast< wxWindow * >(argp1);
36750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36751 if (!SWIG_IsOK(res2)) {
36752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36753 }
36754 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 (arg1)->PushEventHandler(arg2);
36758 wxPyEndAllowThreads(__tstate);
36759 if (PyErr_Occurred()) SWIG_fail;
36760 }
36761 resultobj = SWIG_Py_Void();
36762 return resultobj;
36763 fail:
36764 return NULL;
36765 }
36766
36767
36768 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36769 PyObject *resultobj = 0;
36770 wxWindow *arg1 = (wxWindow *) 0 ;
36771 bool arg2 = (bool) false ;
36772 wxEvtHandler *result = 0 ;
36773 void *argp1 = 0 ;
36774 int res1 = 0 ;
36775 bool val2 ;
36776 int ecode2 = 0 ;
36777 PyObject * obj0 = 0 ;
36778 PyObject * obj1 = 0 ;
36779 char * kwnames[] = {
36780 (char *) "self",(char *) "deleteHandler", NULL
36781 };
36782
36783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36785 if (!SWIG_IsOK(res1)) {
36786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36787 }
36788 arg1 = reinterpret_cast< wxWindow * >(argp1);
36789 if (obj1) {
36790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36791 if (!SWIG_IsOK(ecode2)) {
36792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36793 }
36794 arg2 = static_cast< bool >(val2);
36795 }
36796 {
36797 PyThreadState* __tstate = wxPyBeginAllowThreads();
36798 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36799 wxPyEndAllowThreads(__tstate);
36800 if (PyErr_Occurred()) SWIG_fail;
36801 }
36802 {
36803 resultobj = wxPyMake_wxObject(result, 0);
36804 }
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36812 PyObject *resultobj = 0;
36813 wxWindow *arg1 = (wxWindow *) 0 ;
36814 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36815 bool result;
36816 void *argp1 = 0 ;
36817 int res1 = 0 ;
36818 void *argp2 = 0 ;
36819 int res2 = 0 ;
36820 PyObject * obj0 = 0 ;
36821 PyObject * obj1 = 0 ;
36822 char * kwnames[] = {
36823 (char *) "self",(char *) "handler", NULL
36824 };
36825
36826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36830 }
36831 arg1 = reinterpret_cast< wxWindow * >(argp1);
36832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36833 if (!SWIG_IsOK(res2)) {
36834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36835 }
36836 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = (bool)(arg1)->RemoveEventHandler(arg2);
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36845 }
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj = 0;
36854 wxWindow *arg1 = (wxWindow *) 0 ;
36855 wxValidator *arg2 = 0 ;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 void *argp2 = 0 ;
36859 int res2 = 0 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 char * kwnames[] = {
36863 (char *) "self",(char *) "validator", NULL
36864 };
36865
36866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36873 if (!SWIG_IsOK(res2)) {
36874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36875 }
36876 if (!argp2) {
36877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36878 }
36879 arg2 = reinterpret_cast< wxValidator * >(argp2);
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 (arg1)->SetValidator((wxValidator const &)*arg2);
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 resultobj = SWIG_Py_Void();
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36894 PyObject *resultobj = 0;
36895 wxWindow *arg1 = (wxWindow *) 0 ;
36896 wxValidator *result = 0 ;
36897 void *argp1 = 0 ;
36898 int res1 = 0 ;
36899 PyObject *swig_obj[1] ;
36900
36901 if (!args) SWIG_fail;
36902 swig_obj[0] = args;
36903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36904 if (!SWIG_IsOK(res1)) {
36905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36906 }
36907 arg1 = reinterpret_cast< wxWindow * >(argp1);
36908 {
36909 PyThreadState* __tstate = wxPyBeginAllowThreads();
36910 result = (wxValidator *)(arg1)->GetValidator();
36911 wxPyEndAllowThreads(__tstate);
36912 if (PyErr_Occurred()) SWIG_fail;
36913 }
36914 {
36915 resultobj = wxPyMake_wxObject(result, (bool)0);
36916 }
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36924 PyObject *resultobj = 0;
36925 wxWindow *arg1 = (wxWindow *) 0 ;
36926 bool result;
36927 void *argp1 = 0 ;
36928 int res1 = 0 ;
36929 PyObject *swig_obj[1] ;
36930
36931 if (!args) SWIG_fail;
36932 swig_obj[0] = args;
36933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36934 if (!SWIG_IsOK(res1)) {
36935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36936 }
36937 arg1 = reinterpret_cast< wxWindow * >(argp1);
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 result = (bool)(arg1)->Validate();
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 {
36945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36954 PyObject *resultobj = 0;
36955 wxWindow *arg1 = (wxWindow *) 0 ;
36956 bool result;
36957 void *argp1 = 0 ;
36958 int res1 = 0 ;
36959 PyObject *swig_obj[1] ;
36960
36961 if (!args) SWIG_fail;
36962 swig_obj[0] = args;
36963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36964 if (!SWIG_IsOK(res1)) {
36965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36966 }
36967 arg1 = reinterpret_cast< wxWindow * >(argp1);
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 result = (bool)(arg1)->TransferDataToWindow();
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 {
36975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36976 }
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36984 PyObject *resultobj = 0;
36985 wxWindow *arg1 = (wxWindow *) 0 ;
36986 bool result;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 PyObject *swig_obj[1] ;
36990
36991 if (!args) SWIG_fail;
36992 swig_obj[0] = args;
36993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36996 }
36997 arg1 = reinterpret_cast< wxWindow * >(argp1);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (bool)(arg1)->TransferDataFromWindow();
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37006 }
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37014 PyObject *resultobj = 0;
37015 wxWindow *arg1 = (wxWindow *) 0 ;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 PyObject *swig_obj[1] ;
37019
37020 if (!args) SWIG_fail;
37021 swig_obj[0] = args;
37022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37023 if (!SWIG_IsOK(res1)) {
37024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37025 }
37026 arg1 = reinterpret_cast< wxWindow * >(argp1);
37027 {
37028 PyThreadState* __tstate = wxPyBeginAllowThreads();
37029 (arg1)->InitDialog();
37030 wxPyEndAllowThreads(__tstate);
37031 if (PyErr_Occurred()) SWIG_fail;
37032 }
37033 resultobj = SWIG_Py_Void();
37034 return resultobj;
37035 fail:
37036 return NULL;
37037 }
37038
37039
37040 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37041 PyObject *resultobj = 0;
37042 wxWindow *arg1 = (wxWindow *) 0 ;
37043 wxAcceleratorTable *arg2 = 0 ;
37044 void *argp1 = 0 ;
37045 int res1 = 0 ;
37046 void *argp2 = 0 ;
37047 int res2 = 0 ;
37048 PyObject * obj0 = 0 ;
37049 PyObject * obj1 = 0 ;
37050 char * kwnames[] = {
37051 (char *) "self",(char *) "accel", NULL
37052 };
37053
37054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37056 if (!SWIG_IsOK(res1)) {
37057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37058 }
37059 arg1 = reinterpret_cast< wxWindow * >(argp1);
37060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37061 if (!SWIG_IsOK(res2)) {
37062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37063 }
37064 if (!argp2) {
37065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37066 }
37067 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 resultobj = SWIG_Py_Void();
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37082 PyObject *resultobj = 0;
37083 wxWindow *arg1 = (wxWindow *) 0 ;
37084 wxAcceleratorTable *result = 0 ;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 PyObject *swig_obj[1] ;
37088
37089 if (!args) SWIG_fail;
37090 swig_obj[0] = args;
37091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37092 if (!SWIG_IsOK(res1)) {
37093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37094 }
37095 arg1 = reinterpret_cast< wxWindow * >(argp1);
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 int arg2 ;
37113 int arg3 ;
37114 int arg4 ;
37115 bool result;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 int val2 ;
37119 int ecode2 = 0 ;
37120 int val3 ;
37121 int ecode3 = 0 ;
37122 int val4 ;
37123 int ecode4 = 0 ;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 PyObject * obj2 = 0 ;
37127 PyObject * obj3 = 0 ;
37128 char * kwnames[] = {
37129 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37130 };
37131
37132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37136 }
37137 arg1 = reinterpret_cast< wxWindow * >(argp1);
37138 ecode2 = SWIG_AsVal_int(obj1, &val2);
37139 if (!SWIG_IsOK(ecode2)) {
37140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37141 }
37142 arg2 = static_cast< int >(val2);
37143 ecode3 = SWIG_AsVal_int(obj2, &val3);
37144 if (!SWIG_IsOK(ecode3)) {
37145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37146 }
37147 arg3 = static_cast< int >(val3);
37148 ecode4 = SWIG_AsVal_int(obj3, &val4);
37149 if (!SWIG_IsOK(ecode4)) {
37150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37151 }
37152 arg4 = static_cast< int >(val4);
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37161 }
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 int arg2 ;
37172 bool result;
37173 void *argp1 = 0 ;
37174 int res1 = 0 ;
37175 int val2 ;
37176 int ecode2 = 0 ;
37177 PyObject * obj0 = 0 ;
37178 PyObject * obj1 = 0 ;
37179 char * kwnames[] = {
37180 (char *) "self",(char *) "hotkeyId", NULL
37181 };
37182
37183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37185 if (!SWIG_IsOK(res1)) {
37186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37187 }
37188 arg1 = reinterpret_cast< wxWindow * >(argp1);
37189 ecode2 = SWIG_AsVal_int(obj1, &val2);
37190 if (!SWIG_IsOK(ecode2)) {
37191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37192 }
37193 arg2 = static_cast< int >(val2);
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37202 }
37203 return resultobj;
37204 fail:
37205 return NULL;
37206 }
37207
37208
37209 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37210 PyObject *resultobj = 0;
37211 wxWindow *arg1 = (wxWindow *) 0 ;
37212 wxPoint *arg2 = 0 ;
37213 wxPoint result;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 wxPoint temp2 ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "pt", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 {
37230 arg2 = &temp2;
37231 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37232 }
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 wxSize *arg2 = 0 ;
37250 wxSize result;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 wxSize temp2 ;
37254 PyObject * obj0 = 0 ;
37255 PyObject * obj1 = 0 ;
37256 char * kwnames[] = {
37257 (char *) "self",(char *) "sz", NULL
37258 };
37259
37260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37264 }
37265 arg1 = reinterpret_cast< wxWindow * >(argp1);
37266 {
37267 arg2 = &temp2;
37268 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37269 }
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37277 return resultobj;
37278 fail:
37279 return NULL;
37280 }
37281
37282
37283 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37284 PyObject *resultobj = 0;
37285 wxWindow *arg1 = (wxWindow *) 0 ;
37286 wxPoint *arg2 = 0 ;
37287 wxPoint result;
37288 void *argp1 = 0 ;
37289 int res1 = 0 ;
37290 wxPoint temp2 ;
37291 PyObject * obj0 = 0 ;
37292 PyObject * obj1 = 0 ;
37293 char * kwnames[] = {
37294 (char *) "self",(char *) "pt", NULL
37295 };
37296
37297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 {
37304 arg2 = &temp2;
37305 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37306 }
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37310 wxPyEndAllowThreads(__tstate);
37311 if (PyErr_Occurred()) SWIG_fail;
37312 }
37313 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37314 return resultobj;
37315 fail:
37316 return NULL;
37317 }
37318
37319
37320 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37321 PyObject *resultobj = 0;
37322 wxWindow *arg1 = (wxWindow *) 0 ;
37323 wxSize *arg2 = 0 ;
37324 wxSize result;
37325 void *argp1 = 0 ;
37326 int res1 = 0 ;
37327 wxSize temp2 ;
37328 PyObject * obj0 = 0 ;
37329 PyObject * obj1 = 0 ;
37330 char * kwnames[] = {
37331 (char *) "self",(char *) "sz", NULL
37332 };
37333
37334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37336 if (!SWIG_IsOK(res1)) {
37337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37338 }
37339 arg1 = reinterpret_cast< wxWindow * >(argp1);
37340 {
37341 arg2 = &temp2;
37342 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37343 }
37344 {
37345 PyThreadState* __tstate = wxPyBeginAllowThreads();
37346 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37358 PyObject *resultobj = 0;
37359 wxWindow *arg1 = (wxWindow *) 0 ;
37360 wxPoint *arg2 = 0 ;
37361 wxPoint result;
37362 void *argp1 = 0 ;
37363 int res1 = 0 ;
37364 wxPoint temp2 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 char * kwnames[] = {
37368 (char *) "self",(char *) "pt", NULL
37369 };
37370
37371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37373 if (!SWIG_IsOK(res1)) {
37374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37375 }
37376 arg1 = reinterpret_cast< wxWindow * >(argp1);
37377 {
37378 arg2 = &temp2;
37379 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37380 }
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 wxSize *arg2 = 0 ;
37398 wxSize result;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 wxSize temp2 ;
37402 PyObject * obj0 = 0 ;
37403 PyObject * obj1 = 0 ;
37404 char * kwnames[] = {
37405 (char *) "self",(char *) "sz", NULL
37406 };
37407
37408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 {
37415 arg2 = &temp2;
37416 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37417 }
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37425 return resultobj;
37426 fail:
37427 return NULL;
37428 }
37429
37430
37431 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37432 PyObject *resultobj = 0;
37433 wxWindow *arg1 = (wxWindow *) 0 ;
37434 int arg2 ;
37435 int arg3 ;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 int val2 ;
37439 int ecode2 = 0 ;
37440 int val3 ;
37441 int ecode3 = 0 ;
37442 PyObject * obj0 = 0 ;
37443 PyObject * obj1 = 0 ;
37444 PyObject * obj2 = 0 ;
37445 char * kwnames[] = {
37446 (char *) "self",(char *) "x",(char *) "y", NULL
37447 };
37448
37449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 ecode2 = SWIG_AsVal_int(obj1, &val2);
37456 if (!SWIG_IsOK(ecode2)) {
37457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37458 }
37459 arg2 = static_cast< int >(val2);
37460 ecode3 = SWIG_AsVal_int(obj2, &val3);
37461 if (!SWIG_IsOK(ecode3)) {
37462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37463 }
37464 arg3 = static_cast< int >(val3);
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 (arg1)->WarpPointer(arg2,arg3);
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 resultobj = SWIG_Py_Void();
37472 return resultobj;
37473 fail:
37474 return NULL;
37475 }
37476
37477
37478 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37479 PyObject *resultobj = 0;
37480 wxWindow *arg1 = (wxWindow *) 0 ;
37481 void *argp1 = 0 ;
37482 int res1 = 0 ;
37483 PyObject *swig_obj[1] ;
37484
37485 if (!args) SWIG_fail;
37486 swig_obj[0] = args;
37487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37488 if (!SWIG_IsOK(res1)) {
37489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37490 }
37491 arg1 = reinterpret_cast< wxWindow * >(argp1);
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 (arg1)->CaptureMouse();
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 resultobj = SWIG_Py_Void();
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37506 PyObject *resultobj = 0;
37507 wxWindow *arg1 = (wxWindow *) 0 ;
37508 void *argp1 = 0 ;
37509 int res1 = 0 ;
37510 PyObject *swig_obj[1] ;
37511
37512 if (!args) SWIG_fail;
37513 swig_obj[0] = args;
37514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37515 if (!SWIG_IsOK(res1)) {
37516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37517 }
37518 arg1 = reinterpret_cast< wxWindow * >(argp1);
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 (arg1)->ReleaseMouse();
37522 wxPyEndAllowThreads(__tstate);
37523 if (PyErr_Occurred()) SWIG_fail;
37524 }
37525 resultobj = SWIG_Py_Void();
37526 return resultobj;
37527 fail:
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37533 PyObject *resultobj = 0;
37534 wxWindow *result = 0 ;
37535
37536 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37537 {
37538 if (!wxPyCheckForApp()) SWIG_fail;
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 result = (wxWindow *)wxWindow::GetCapture();
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 {
37545 resultobj = wxPyMake_wxObject(result, 0);
37546 }
37547 return resultobj;
37548 fail:
37549 return NULL;
37550 }
37551
37552
37553 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37554 PyObject *resultobj = 0;
37555 wxWindow *arg1 = (wxWindow *) 0 ;
37556 bool result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 PyObject *swig_obj[1] ;
37560
37561 if (!args) SWIG_fail;
37562 swig_obj[0] = args;
37563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37564 if (!SWIG_IsOK(res1)) {
37565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37566 }
37567 arg1 = reinterpret_cast< wxWindow * >(argp1);
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = (bool)((wxWindow const *)arg1)->HasCapture();
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 {
37575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37576 }
37577 return resultobj;
37578 fail:
37579 return NULL;
37580 }
37581
37582
37583 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj = 0;
37585 wxWindow *arg1 = (wxWindow *) 0 ;
37586 bool arg2 = (bool) true ;
37587 wxRect *arg3 = (wxRect *) NULL ;
37588 void *argp1 = 0 ;
37589 int res1 = 0 ;
37590 bool val2 ;
37591 int ecode2 = 0 ;
37592 void *argp3 = 0 ;
37593 int res3 = 0 ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 PyObject * obj2 = 0 ;
37597 char * kwnames[] = {
37598 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37599 };
37600
37601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37605 }
37606 arg1 = reinterpret_cast< wxWindow * >(argp1);
37607 if (obj1) {
37608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37609 if (!SWIG_IsOK(ecode2)) {
37610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37611 }
37612 arg2 = static_cast< bool >(val2);
37613 }
37614 if (obj2) {
37615 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37616 if (!SWIG_IsOK(res3)) {
37617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37618 }
37619 arg3 = reinterpret_cast< wxRect * >(argp3);
37620 }
37621 {
37622 PyThreadState* __tstate = wxPyBeginAllowThreads();
37623 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 resultobj = SWIG_Py_Void();
37628 return resultobj;
37629 fail:
37630 return NULL;
37631 }
37632
37633
37634 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37635 PyObject *resultobj = 0;
37636 wxWindow *arg1 = (wxWindow *) 0 ;
37637 wxRect *arg2 = 0 ;
37638 bool arg3 = (bool) true ;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 wxRect temp2 ;
37642 bool val3 ;
37643 int ecode3 = 0 ;
37644 PyObject * obj0 = 0 ;
37645 PyObject * obj1 = 0 ;
37646 PyObject * obj2 = 0 ;
37647 char * kwnames[] = {
37648 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37649 };
37650
37651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37653 if (!SWIG_IsOK(res1)) {
37654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37655 }
37656 arg1 = reinterpret_cast< wxWindow * >(argp1);
37657 {
37658 arg2 = &temp2;
37659 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37660 }
37661 if (obj2) {
37662 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37663 if (!SWIG_IsOK(ecode3)) {
37664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37665 }
37666 arg3 = static_cast< bool >(val3);
37667 }
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37671 wxPyEndAllowThreads(__tstate);
37672 if (PyErr_Occurred()) SWIG_fail;
37673 }
37674 resultobj = SWIG_Py_Void();
37675 return resultobj;
37676 fail:
37677 return NULL;
37678 }
37679
37680
37681 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37682 PyObject *resultobj = 0;
37683 wxWindow *arg1 = (wxWindow *) 0 ;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 PyObject *swig_obj[1] ;
37687
37688 if (!args) SWIG_fail;
37689 swig_obj[0] = args;
37690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37691 if (!SWIG_IsOK(res1)) {
37692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37693 }
37694 arg1 = reinterpret_cast< wxWindow * >(argp1);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 (arg1)->Update();
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 resultobj = SWIG_Py_Void();
37702 return resultobj;
37703 fail:
37704 return NULL;
37705 }
37706
37707
37708 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37709 PyObject *resultobj = 0;
37710 wxWindow *arg1 = (wxWindow *) 0 ;
37711 void *argp1 = 0 ;
37712 int res1 = 0 ;
37713 PyObject *swig_obj[1] ;
37714
37715 if (!args) SWIG_fail;
37716 swig_obj[0] = args;
37717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37718 if (!SWIG_IsOK(res1)) {
37719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37720 }
37721 arg1 = reinterpret_cast< wxWindow * >(argp1);
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 (arg1)->ClearBackground();
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 resultobj = SWIG_Py_Void();
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37736 PyObject *resultobj = 0;
37737 wxWindow *arg1 = (wxWindow *) 0 ;
37738 void *argp1 = 0 ;
37739 int res1 = 0 ;
37740 PyObject *swig_obj[1] ;
37741
37742 if (!args) SWIG_fail;
37743 swig_obj[0] = args;
37744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37745 if (!SWIG_IsOK(res1)) {
37746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37747 }
37748 arg1 = reinterpret_cast< wxWindow * >(argp1);
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 (arg1)->Freeze();
37752 wxPyEndAllowThreads(__tstate);
37753 if (PyErr_Occurred()) SWIG_fail;
37754 }
37755 resultobj = SWIG_Py_Void();
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37763 PyObject *resultobj = 0;
37764 wxWindow *arg1 = (wxWindow *) 0 ;
37765 bool result;
37766 void *argp1 = 0 ;
37767 int res1 = 0 ;
37768 PyObject *swig_obj[1] ;
37769
37770 if (!args) SWIG_fail;
37771 swig_obj[0] = args;
37772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37773 if (!SWIG_IsOK(res1)) {
37774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37775 }
37776 arg1 = reinterpret_cast< wxWindow * >(argp1);
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37785 }
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37793 PyObject *resultobj = 0;
37794 wxWindow *arg1 = (wxWindow *) 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 PyObject *swig_obj[1] ;
37798
37799 if (!args) SWIG_fail;
37800 swig_obj[0] = args;
37801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37802 if (!SWIG_IsOK(res1)) {
37803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37804 }
37805 arg1 = reinterpret_cast< wxWindow * >(argp1);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 (arg1)->Thaw();
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 resultobj = SWIG_Py_Void();
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxWindow *arg1 = (wxWindow *) 0 ;
37822 wxDC *arg2 = 0 ;
37823 void *argp1 = 0 ;
37824 int res1 = 0 ;
37825 void *argp2 = 0 ;
37826 int res2 = 0 ;
37827 PyObject * obj0 = 0 ;
37828 PyObject * obj1 = 0 ;
37829 char * kwnames[] = {
37830 (char *) "self",(char *) "dc", NULL
37831 };
37832
37833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37840 if (!SWIG_IsOK(res2)) {
37841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37842 }
37843 if (!argp2) {
37844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37845 }
37846 arg2 = reinterpret_cast< wxDC * >(argp2);
37847 {
37848 PyThreadState* __tstate = wxPyBeginAllowThreads();
37849 (arg1)->PrepareDC(*arg2);
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 resultobj = SWIG_Py_Void();
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 wxWindow *arg1 = (wxWindow *) 0 ;
37863 bool result;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 PyObject *swig_obj[1] ;
37867
37868 if (!args) SWIG_fail;
37869 swig_obj[0] = args;
37870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37873 }
37874 arg1 = reinterpret_cast< wxWindow * >(argp1);
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37883 }
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxWindow *arg1 = (wxWindow *) 0 ;
37893 wxRegion *result = 0 ;
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_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37903 }
37904 arg1 = reinterpret_cast< wxWindow * >(argp1);
37905 {
37906 PyThreadState* __tstate = wxPyBeginAllowThreads();
37907 {
37908 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37909 result = (wxRegion *) &_result_ref;
37910 }
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxWindow *arg1 = (wxWindow *) 0 ;
37924 wxRect result;
37925 void *argp1 = 0 ;
37926 int res1 = 0 ;
37927 PyObject *swig_obj[1] ;
37928
37929 if (!args) SWIG_fail;
37930 swig_obj[0] = args;
37931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37932 if (!SWIG_IsOK(res1)) {
37933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37934 }
37935 arg1 = reinterpret_cast< wxWindow * >(argp1);
37936 {
37937 PyThreadState* __tstate = wxPyBeginAllowThreads();
37938 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37943 return resultobj;
37944 fail:
37945 return NULL;
37946 }
37947
37948
37949 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37950 PyObject *resultobj = 0;
37951 wxWindow *arg1 = (wxWindow *) 0 ;
37952 int arg2 ;
37953 int arg3 ;
37954 int arg4 = (int) 1 ;
37955 int arg5 = (int) 1 ;
37956 bool result;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 int val2 ;
37960 int ecode2 = 0 ;
37961 int val3 ;
37962 int ecode3 = 0 ;
37963 int val4 ;
37964 int ecode4 = 0 ;
37965 int val5 ;
37966 int ecode5 = 0 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 PyObject * obj2 = 0 ;
37970 PyObject * obj3 = 0 ;
37971 PyObject * obj4 = 0 ;
37972 char * kwnames[] = {
37973 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37974 };
37975
37976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37978 if (!SWIG_IsOK(res1)) {
37979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37980 }
37981 arg1 = reinterpret_cast< wxWindow * >(argp1);
37982 ecode2 = SWIG_AsVal_int(obj1, &val2);
37983 if (!SWIG_IsOK(ecode2)) {
37984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37985 }
37986 arg2 = static_cast< int >(val2);
37987 ecode3 = SWIG_AsVal_int(obj2, &val3);
37988 if (!SWIG_IsOK(ecode3)) {
37989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37990 }
37991 arg3 = static_cast< int >(val3);
37992 if (obj3) {
37993 ecode4 = SWIG_AsVal_int(obj3, &val4);
37994 if (!SWIG_IsOK(ecode4)) {
37995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37996 }
37997 arg4 = static_cast< int >(val4);
37998 }
37999 if (obj4) {
38000 ecode5 = SWIG_AsVal_int(obj4, &val5);
38001 if (!SWIG_IsOK(ecode5)) {
38002 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38003 }
38004 arg5 = static_cast< int >(val5);
38005 }
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38014 }
38015 return resultobj;
38016 fail:
38017 return NULL;
38018 }
38019
38020
38021 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38022 PyObject *resultobj = 0;
38023 wxWindow *arg1 = (wxWindow *) 0 ;
38024 wxPoint *arg2 = 0 ;
38025 bool result;
38026 void *argp1 = 0 ;
38027 int res1 = 0 ;
38028 wxPoint temp2 ;
38029 PyObject * obj0 = 0 ;
38030 PyObject * obj1 = 0 ;
38031 char * kwnames[] = {
38032 (char *) "self",(char *) "pt", NULL
38033 };
38034
38035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38037 if (!SWIG_IsOK(res1)) {
38038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38039 }
38040 arg1 = reinterpret_cast< wxWindow * >(argp1);
38041 {
38042 arg2 = &temp2;
38043 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38044 }
38045 {
38046 PyThreadState* __tstate = wxPyBeginAllowThreads();
38047 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38048 wxPyEndAllowThreads(__tstate);
38049 if (PyErr_Occurred()) SWIG_fail;
38050 }
38051 {
38052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38053 }
38054 return resultobj;
38055 fail:
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxWindow *arg1 = (wxWindow *) 0 ;
38063 wxRect *arg2 = 0 ;
38064 bool result;
38065 void *argp1 = 0 ;
38066 int res1 = 0 ;
38067 wxRect temp2 ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 char * kwnames[] = {
38071 (char *) "self",(char *) "rect", NULL
38072 };
38073
38074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38078 }
38079 arg1 = reinterpret_cast< wxWindow * >(argp1);
38080 {
38081 arg2 = &temp2;
38082 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38083 }
38084 {
38085 PyThreadState* __tstate = wxPyBeginAllowThreads();
38086 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38087 wxPyEndAllowThreads(__tstate);
38088 if (PyErr_Occurred()) SWIG_fail;
38089 }
38090 {
38091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38092 }
38093 return resultobj;
38094 fail:
38095 return NULL;
38096 }
38097
38098
38099 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38100 PyObject *resultobj = 0;
38101 wxWindow *arg1 = (wxWindow *) 0 ;
38102 SwigValueWrapper<wxVisualAttributes > result;
38103 void *argp1 = 0 ;
38104 int res1 = 0 ;
38105 PyObject *swig_obj[1] ;
38106
38107 if (!args) SWIG_fail;
38108 swig_obj[0] = args;
38109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38112 }
38113 arg1 = reinterpret_cast< wxWindow * >(argp1);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38121 return resultobj;
38122 fail:
38123 return NULL;
38124 }
38125
38126
38127 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38128 PyObject *resultobj = 0;
38129 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38130 SwigValueWrapper<wxVisualAttributes > result;
38131 int val1 ;
38132 int ecode1 = 0 ;
38133 PyObject * obj0 = 0 ;
38134 char * kwnames[] = {
38135 (char *) "variant", NULL
38136 };
38137
38138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38139 if (obj0) {
38140 ecode1 = SWIG_AsVal_int(obj0, &val1);
38141 if (!SWIG_IsOK(ecode1)) {
38142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38143 }
38144 arg1 = static_cast< wxWindowVariant >(val1);
38145 }
38146 {
38147 if (!wxPyCheckForApp()) SWIG_fail;
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 result = wxWindow::GetClassDefaultAttributes(arg1);
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj = 0;
38162 wxWindow *arg1 = (wxWindow *) 0 ;
38163 wxColour *arg2 = 0 ;
38164 bool result;
38165 void *argp1 = 0 ;
38166 int res1 = 0 ;
38167 wxColour temp2 ;
38168 PyObject * obj0 = 0 ;
38169 PyObject * obj1 = 0 ;
38170 char * kwnames[] = {
38171 (char *) "self",(char *) "colour", NULL
38172 };
38173
38174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38176 if (!SWIG_IsOK(res1)) {
38177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38178 }
38179 arg1 = reinterpret_cast< wxWindow * >(argp1);
38180 {
38181 arg2 = &temp2;
38182 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38183 }
38184 {
38185 PyThreadState* __tstate = wxPyBeginAllowThreads();
38186 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38187 wxPyEndAllowThreads(__tstate);
38188 if (PyErr_Occurred()) SWIG_fail;
38189 }
38190 {
38191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38192 }
38193 return resultobj;
38194 fail:
38195 return NULL;
38196 }
38197
38198
38199 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38200 PyObject *resultobj = 0;
38201 wxWindow *arg1 = (wxWindow *) 0 ;
38202 wxColour *arg2 = 0 ;
38203 void *argp1 = 0 ;
38204 int res1 = 0 ;
38205 wxColour temp2 ;
38206 PyObject * obj0 = 0 ;
38207 PyObject * obj1 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "colour", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 arg2 = &temp2;
38220 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38221 }
38222 {
38223 PyThreadState* __tstate = wxPyBeginAllowThreads();
38224 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38225 wxPyEndAllowThreads(__tstate);
38226 if (PyErr_Occurred()) SWIG_fail;
38227 }
38228 resultobj = SWIG_Py_Void();
38229 return resultobj;
38230 fail:
38231 return NULL;
38232 }
38233
38234
38235 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38236 PyObject *resultobj = 0;
38237 wxWindow *arg1 = (wxWindow *) 0 ;
38238 wxColour *arg2 = 0 ;
38239 bool result;
38240 void *argp1 = 0 ;
38241 int res1 = 0 ;
38242 wxColour temp2 ;
38243 PyObject * obj0 = 0 ;
38244 PyObject * obj1 = 0 ;
38245 char * kwnames[] = {
38246 (char *) "self",(char *) "colour", NULL
38247 };
38248
38249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38251 if (!SWIG_IsOK(res1)) {
38252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38253 }
38254 arg1 = reinterpret_cast< wxWindow * >(argp1);
38255 {
38256 arg2 = &temp2;
38257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38258 }
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38262 wxPyEndAllowThreads(__tstate);
38263 if (PyErr_Occurred()) SWIG_fail;
38264 }
38265 {
38266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38267 }
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 wxColour *arg2 = 0 ;
38278 void *argp1 = 0 ;
38279 int res1 = 0 ;
38280 wxColour temp2 ;
38281 PyObject * obj0 = 0 ;
38282 PyObject * obj1 = 0 ;
38283 char * kwnames[] = {
38284 (char *) "self",(char *) "colour", NULL
38285 };
38286
38287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38289 if (!SWIG_IsOK(res1)) {
38290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38291 }
38292 arg1 = reinterpret_cast< wxWindow * >(argp1);
38293 {
38294 arg2 = &temp2;
38295 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38296 }
38297 {
38298 PyThreadState* __tstate = wxPyBeginAllowThreads();
38299 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38300 wxPyEndAllowThreads(__tstate);
38301 if (PyErr_Occurred()) SWIG_fail;
38302 }
38303 resultobj = SWIG_Py_Void();
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38311 PyObject *resultobj = 0;
38312 wxWindow *arg1 = (wxWindow *) 0 ;
38313 wxColour result;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 PyObject *swig_obj[1] ;
38317
38318 if (!args) SWIG_fail;
38319 swig_obj[0] = args;
38320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxWindow * >(argp1);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38332 return resultobj;
38333 fail:
38334 return NULL;
38335 }
38336
38337
38338 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38339 PyObject *resultobj = 0;
38340 wxWindow *arg1 = (wxWindow *) 0 ;
38341 wxColour result;
38342 void *argp1 = 0 ;
38343 int res1 = 0 ;
38344 PyObject *swig_obj[1] ;
38345
38346 if (!args) SWIG_fail;
38347 swig_obj[0] = args;
38348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38349 if (!SWIG_IsOK(res1)) {
38350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38351 }
38352 arg1 = reinterpret_cast< wxWindow * >(argp1);
38353 {
38354 PyThreadState* __tstate = wxPyBeginAllowThreads();
38355 result = ((wxWindow const *)arg1)->GetForegroundColour();
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38360 return resultobj;
38361 fail:
38362 return NULL;
38363 }
38364
38365
38366 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38367 PyObject *resultobj = 0;
38368 wxWindow *arg1 = (wxWindow *) 0 ;
38369 bool result;
38370 void *argp1 = 0 ;
38371 int res1 = 0 ;
38372 PyObject *swig_obj[1] ;
38373
38374 if (!args) SWIG_fail;
38375 swig_obj[0] = args;
38376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38377 if (!SWIG_IsOK(res1)) {
38378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38379 }
38380 arg1 = reinterpret_cast< wxWindow * >(argp1);
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 {
38388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38389 }
38390 return resultobj;
38391 fail:
38392 return NULL;
38393 }
38394
38395
38396 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38397 PyObject *resultobj = 0;
38398 wxWindow *arg1 = (wxWindow *) 0 ;
38399 bool result;
38400 void *argp1 = 0 ;
38401 int res1 = 0 ;
38402 PyObject *swig_obj[1] ;
38403
38404 if (!args) SWIG_fail;
38405 swig_obj[0] = args;
38406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38407 if (!SWIG_IsOK(res1)) {
38408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38409 }
38410 arg1 = reinterpret_cast< wxWindow * >(argp1);
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38414 wxPyEndAllowThreads(__tstate);
38415 if (PyErr_Occurred()) SWIG_fail;
38416 }
38417 {
38418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38419 }
38420 return resultobj;
38421 fail:
38422 return NULL;
38423 }
38424
38425
38426 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38427 PyObject *resultobj = 0;
38428 wxWindow *arg1 = (wxWindow *) 0 ;
38429 wxBackgroundStyle arg2 ;
38430 bool result;
38431 void *argp1 = 0 ;
38432 int res1 = 0 ;
38433 int val2 ;
38434 int ecode2 = 0 ;
38435 PyObject * obj0 = 0 ;
38436 PyObject * obj1 = 0 ;
38437 char * kwnames[] = {
38438 (char *) "self",(char *) "style", NULL
38439 };
38440
38441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38443 if (!SWIG_IsOK(res1)) {
38444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38445 }
38446 arg1 = reinterpret_cast< wxWindow * >(argp1);
38447 ecode2 = SWIG_AsVal_int(obj1, &val2);
38448 if (!SWIG_IsOK(ecode2)) {
38449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38450 }
38451 arg2 = static_cast< wxBackgroundStyle >(val2);
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 {
38459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38460 }
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38468 PyObject *resultobj = 0;
38469 wxWindow *arg1 = (wxWindow *) 0 ;
38470 wxBackgroundStyle result;
38471 void *argp1 = 0 ;
38472 int res1 = 0 ;
38473 PyObject *swig_obj[1] ;
38474
38475 if (!args) SWIG_fail;
38476 swig_obj[0] = args;
38477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38478 if (!SWIG_IsOK(res1)) {
38479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38480 }
38481 arg1 = reinterpret_cast< wxWindow * >(argp1);
38482 {
38483 PyThreadState* __tstate = wxPyBeginAllowThreads();
38484 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 resultobj = SWIG_From_int(static_cast< int >(result));
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38496 PyObject *resultobj = 0;
38497 wxWindow *arg1 = (wxWindow *) 0 ;
38498 bool result;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 PyObject *swig_obj[1] ;
38502
38503 if (!args) SWIG_fail;
38504 swig_obj[0] = args;
38505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38506 if (!SWIG_IsOK(res1)) {
38507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38508 }
38509 arg1 = reinterpret_cast< wxWindow * >(argp1);
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 result = (bool)(arg1)->HasTransparentBackground();
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 {
38517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38518 }
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj = 0;
38527 wxWindow *arg1 = (wxWindow *) 0 ;
38528 wxCursor *arg2 = 0 ;
38529 bool result;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 void *argp2 = 0 ;
38533 int res2 = 0 ;
38534 PyObject * obj0 = 0 ;
38535 PyObject * obj1 = 0 ;
38536 char * kwnames[] = {
38537 (char *) "self",(char *) "cursor", NULL
38538 };
38539
38540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38542 if (!SWIG_IsOK(res1)) {
38543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38544 }
38545 arg1 = reinterpret_cast< wxWindow * >(argp1);
38546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38547 if (!SWIG_IsOK(res2)) {
38548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38549 }
38550 if (!argp2) {
38551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38552 }
38553 arg2 = reinterpret_cast< wxCursor * >(argp2);
38554 {
38555 PyThreadState* __tstate = wxPyBeginAllowThreads();
38556 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 {
38561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38562 }
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38570 PyObject *resultobj = 0;
38571 wxWindow *arg1 = (wxWindow *) 0 ;
38572 wxCursor result;
38573 void *argp1 = 0 ;
38574 int res1 = 0 ;
38575 PyObject *swig_obj[1] ;
38576
38577 if (!args) SWIG_fail;
38578 swig_obj[0] = args;
38579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38580 if (!SWIG_IsOK(res1)) {
38581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38582 }
38583 arg1 = reinterpret_cast< wxWindow * >(argp1);
38584 {
38585 PyThreadState* __tstate = wxPyBeginAllowThreads();
38586 result = (arg1)->GetCursor();
38587 wxPyEndAllowThreads(__tstate);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 }
38590 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38591 return resultobj;
38592 fail:
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38598 PyObject *resultobj = 0;
38599 wxWindow *arg1 = (wxWindow *) 0 ;
38600 wxFont *arg2 = 0 ;
38601 bool result;
38602 void *argp1 = 0 ;
38603 int res1 = 0 ;
38604 void *argp2 = 0 ;
38605 int res2 = 0 ;
38606 PyObject * obj0 = 0 ;
38607 PyObject * obj1 = 0 ;
38608 char * kwnames[] = {
38609 (char *) "self",(char *) "font", NULL
38610 };
38611
38612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38619 if (!SWIG_IsOK(res2)) {
38620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38621 }
38622 if (!argp2) {
38623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38624 }
38625 arg2 = reinterpret_cast< wxFont * >(argp2);
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38629 wxPyEndAllowThreads(__tstate);
38630 if (PyErr_Occurred()) SWIG_fail;
38631 }
38632 {
38633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38634 }
38635 return resultobj;
38636 fail:
38637 return NULL;
38638 }
38639
38640
38641 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38642 PyObject *resultobj = 0;
38643 wxWindow *arg1 = (wxWindow *) 0 ;
38644 wxFont *arg2 = 0 ;
38645 void *argp1 = 0 ;
38646 int res1 = 0 ;
38647 void *argp2 = 0 ;
38648 int res2 = 0 ;
38649 PyObject * obj0 = 0 ;
38650 PyObject * obj1 = 0 ;
38651 char * kwnames[] = {
38652 (char *) "self",(char *) "font", NULL
38653 };
38654
38655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38659 }
38660 arg1 = reinterpret_cast< wxWindow * >(argp1);
38661 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38662 if (!SWIG_IsOK(res2)) {
38663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38664 }
38665 if (!argp2) {
38666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38667 }
38668 arg2 = reinterpret_cast< wxFont * >(argp2);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 (arg1)->SetOwnFont((wxFont const &)*arg2);
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 resultobj = SWIG_Py_Void();
38676 return resultobj;
38677 fail:
38678 return NULL;
38679 }
38680
38681
38682 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38683 PyObject *resultobj = 0;
38684 wxWindow *arg1 = (wxWindow *) 0 ;
38685 wxFont result;
38686 void *argp1 = 0 ;
38687 int res1 = 0 ;
38688 PyObject *swig_obj[1] ;
38689
38690 if (!args) SWIG_fail;
38691 swig_obj[0] = args;
38692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38693 if (!SWIG_IsOK(res1)) {
38694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38695 }
38696 arg1 = reinterpret_cast< wxWindow * >(argp1);
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (arg1)->GetFont();
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj = 0;
38712 wxWindow *arg1 = (wxWindow *) 0 ;
38713 wxCaret *arg2 = (wxCaret *) 0 ;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 int res2 = 0 ;
38717 PyObject * obj0 = 0 ;
38718 PyObject * obj1 = 0 ;
38719 char * kwnames[] = {
38720 (char *) "self",(char *) "caret", NULL
38721 };
38722
38723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38727 }
38728 arg1 = reinterpret_cast< wxWindow * >(argp1);
38729 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38730 if (!SWIG_IsOK(res2)) {
38731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38732 }
38733 {
38734 PyThreadState* __tstate = wxPyBeginAllowThreads();
38735 (arg1)->SetCaret(arg2);
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 resultobj = SWIG_Py_Void();
38740 return resultobj;
38741 fail:
38742 return NULL;
38743 }
38744
38745
38746 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38747 PyObject *resultobj = 0;
38748 wxWindow *arg1 = (wxWindow *) 0 ;
38749 wxCaret *result = 0 ;
38750 void *argp1 = 0 ;
38751 int res1 = 0 ;
38752 PyObject *swig_obj[1] ;
38753
38754 if (!args) SWIG_fail;
38755 swig_obj[0] = args;
38756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38757 if (!SWIG_IsOK(res1)) {
38758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38759 }
38760 arg1 = reinterpret_cast< wxWindow * >(argp1);
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38764 wxPyEndAllowThreads(__tstate);
38765 if (PyErr_Occurred()) SWIG_fail;
38766 }
38767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *resultobj = 0;
38776 wxWindow *arg1 = (wxWindow *) 0 ;
38777 int result;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 PyObject *swig_obj[1] ;
38781
38782 if (!args) SWIG_fail;
38783 swig_obj[0] = args;
38784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38785 if (!SWIG_IsOK(res1)) {
38786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38787 }
38788 arg1 = reinterpret_cast< wxWindow * >(argp1);
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 resultobj = SWIG_From_int(static_cast< int >(result));
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38803 PyObject *resultobj = 0;
38804 wxWindow *arg1 = (wxWindow *) 0 ;
38805 int result;
38806 void *argp1 = 0 ;
38807 int res1 = 0 ;
38808 PyObject *swig_obj[1] ;
38809
38810 if (!args) SWIG_fail;
38811 swig_obj[0] = args;
38812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38813 if (!SWIG_IsOK(res1)) {
38814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38815 }
38816 arg1 = reinterpret_cast< wxWindow * >(argp1);
38817 {
38818 PyThreadState* __tstate = wxPyBeginAllowThreads();
38819 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 resultobj = SWIG_From_int(static_cast< int >(result));
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj = 0;
38832 wxWindow *arg1 = (wxWindow *) 0 ;
38833 wxString *arg2 = 0 ;
38834 int *arg3 = (int *) 0 ;
38835 int *arg4 = (int *) 0 ;
38836 void *argp1 = 0 ;
38837 int res1 = 0 ;
38838 bool temp2 = false ;
38839 int temp3 ;
38840 int res3 = SWIG_TMPOBJ ;
38841 int temp4 ;
38842 int res4 = SWIG_TMPOBJ ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char * kwnames[] = {
38846 (char *) "self",(char *) "string", NULL
38847 };
38848
38849 arg3 = &temp3;
38850 arg4 = &temp4;
38851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38853 if (!SWIG_IsOK(res1)) {
38854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38855 }
38856 arg1 = reinterpret_cast< wxWindow * >(argp1);
38857 {
38858 arg2 = wxString_in_helper(obj1);
38859 if (arg2 == NULL) SWIG_fail;
38860 temp2 = true;
38861 }
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38865 wxPyEndAllowThreads(__tstate);
38866 if (PyErr_Occurred()) SWIG_fail;
38867 }
38868 resultobj = SWIG_Py_Void();
38869 if (SWIG_IsTmpObj(res3)) {
38870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38871 } else {
38872 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38874 }
38875 if (SWIG_IsTmpObj(res4)) {
38876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38877 } else {
38878 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38880 }
38881 {
38882 if (temp2)
38883 delete arg2;
38884 }
38885 return resultobj;
38886 fail:
38887 {
38888 if (temp2)
38889 delete arg2;
38890 }
38891 return NULL;
38892 }
38893
38894
38895 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38896 PyObject *resultobj = 0;
38897 wxWindow *arg1 = (wxWindow *) 0 ;
38898 wxString *arg2 = 0 ;
38899 int *arg3 = (int *) 0 ;
38900 int *arg4 = (int *) 0 ;
38901 int *arg5 = (int *) 0 ;
38902 int *arg6 = (int *) 0 ;
38903 wxFont *arg7 = (wxFont *) NULL ;
38904 void *argp1 = 0 ;
38905 int res1 = 0 ;
38906 bool temp2 = false ;
38907 int temp3 ;
38908 int res3 = SWIG_TMPOBJ ;
38909 int temp4 ;
38910 int res4 = SWIG_TMPOBJ ;
38911 int temp5 ;
38912 int res5 = SWIG_TMPOBJ ;
38913 int temp6 ;
38914 int res6 = SWIG_TMPOBJ ;
38915 void *argp7 = 0 ;
38916 int res7 = 0 ;
38917 PyObject * obj0 = 0 ;
38918 PyObject * obj1 = 0 ;
38919 PyObject * obj2 = 0 ;
38920 char * kwnames[] = {
38921 (char *) "self",(char *) "string",(char *) "font", NULL
38922 };
38923
38924 arg3 = &temp3;
38925 arg4 = &temp4;
38926 arg5 = &temp5;
38927 arg6 = &temp6;
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38932 }
38933 arg1 = reinterpret_cast< wxWindow * >(argp1);
38934 {
38935 arg2 = wxString_in_helper(obj1);
38936 if (arg2 == NULL) SWIG_fail;
38937 temp2 = true;
38938 }
38939 if (obj2) {
38940 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38941 if (!SWIG_IsOK(res7)) {
38942 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38943 }
38944 arg7 = reinterpret_cast< wxFont * >(argp7);
38945 }
38946 {
38947 PyThreadState* __tstate = wxPyBeginAllowThreads();
38948 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38949 wxPyEndAllowThreads(__tstate);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 }
38952 resultobj = SWIG_Py_Void();
38953 if (SWIG_IsTmpObj(res3)) {
38954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38955 } else {
38956 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38958 }
38959 if (SWIG_IsTmpObj(res4)) {
38960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38961 } else {
38962 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38964 }
38965 if (SWIG_IsTmpObj(res5)) {
38966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38967 } else {
38968 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38970 }
38971 if (SWIG_IsTmpObj(res6)) {
38972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38973 } else {
38974 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38976 }
38977 {
38978 if (temp2)
38979 delete arg2;
38980 }
38981 return resultobj;
38982 fail:
38983 {
38984 if (temp2)
38985 delete arg2;
38986 }
38987 return NULL;
38988 }
38989
38990
38991 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38992 PyObject *resultobj = 0;
38993 wxWindow *arg1 = (wxWindow *) 0 ;
38994 int *arg2 = (int *) 0 ;
38995 int *arg3 = (int *) 0 ;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 int temp2 ;
38999 int res2 = 0 ;
39000 int temp3 ;
39001 int res3 = 0 ;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 PyObject * obj2 = 0 ;
39005 char * kwnames[] = {
39006 (char *) "self",(char *) "x",(char *) "y", NULL
39007 };
39008
39009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39011 if (!SWIG_IsOK(res1)) {
39012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39013 }
39014 arg1 = reinterpret_cast< wxWindow * >(argp1);
39015 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39016 int val;
39017 int ecode = SWIG_AsVal_int(obj1, &val);
39018 if (!SWIG_IsOK(ecode)) {
39019 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39020 }
39021 temp2 = static_cast< int >(val);
39022 arg2 = &temp2;
39023 res2 = SWIG_AddTmpMask(ecode);
39024 }
39025 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39026 int val;
39027 int ecode = SWIG_AsVal_int(obj2, &val);
39028 if (!SWIG_IsOK(ecode)) {
39029 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39030 }
39031 temp3 = static_cast< int >(val);
39032 arg3 = &temp3;
39033 res3 = SWIG_AddTmpMask(ecode);
39034 }
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 resultobj = SWIG_Py_Void();
39042 if (SWIG_IsTmpObj(res2)) {
39043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39044 } else {
39045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39047 }
39048 if (SWIG_IsTmpObj(res3)) {
39049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39050 } else {
39051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39053 }
39054 return resultobj;
39055 fail:
39056 return NULL;
39057 }
39058
39059
39060 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj = 0;
39062 wxWindow *arg1 = (wxWindow *) 0 ;
39063 int *arg2 = (int *) 0 ;
39064 int *arg3 = (int *) 0 ;
39065 void *argp1 = 0 ;
39066 int res1 = 0 ;
39067 int temp2 ;
39068 int res2 = 0 ;
39069 int temp3 ;
39070 int res3 = 0 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 PyObject * obj2 = 0 ;
39074 char * kwnames[] = {
39075 (char *) "self",(char *) "x",(char *) "y", NULL
39076 };
39077
39078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39080 if (!SWIG_IsOK(res1)) {
39081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39082 }
39083 arg1 = reinterpret_cast< wxWindow * >(argp1);
39084 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39085 int val;
39086 int ecode = SWIG_AsVal_int(obj1, &val);
39087 if (!SWIG_IsOK(ecode)) {
39088 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39089 }
39090 temp2 = static_cast< int >(val);
39091 arg2 = &temp2;
39092 res2 = SWIG_AddTmpMask(ecode);
39093 }
39094 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39095 int val;
39096 int ecode = SWIG_AsVal_int(obj2, &val);
39097 if (!SWIG_IsOK(ecode)) {
39098 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39099 }
39100 temp3 = static_cast< int >(val);
39101 arg3 = &temp3;
39102 res3 = SWIG_AddTmpMask(ecode);
39103 }
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 resultobj = SWIG_Py_Void();
39111 if (SWIG_IsTmpObj(res2)) {
39112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39113 } else {
39114 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39116 }
39117 if (SWIG_IsTmpObj(res3)) {
39118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39119 } else {
39120 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39122 }
39123 return resultobj;
39124 fail:
39125 return NULL;
39126 }
39127
39128
39129 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39130 PyObject *resultobj = 0;
39131 wxWindow *arg1 = (wxWindow *) 0 ;
39132 wxPoint *arg2 = 0 ;
39133 wxPoint result;
39134 void *argp1 = 0 ;
39135 int res1 = 0 ;
39136 wxPoint temp2 ;
39137 PyObject * obj0 = 0 ;
39138 PyObject * obj1 = 0 ;
39139 char * kwnames[] = {
39140 (char *) "self",(char *) "pt", NULL
39141 };
39142
39143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39145 if (!SWIG_IsOK(res1)) {
39146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39147 }
39148 arg1 = reinterpret_cast< wxWindow * >(argp1);
39149 {
39150 arg2 = &temp2;
39151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39152 }
39153 {
39154 PyThreadState* __tstate = wxPyBeginAllowThreads();
39155 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39156 wxPyEndAllowThreads(__tstate);
39157 if (PyErr_Occurred()) SWIG_fail;
39158 }
39159 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39160 return resultobj;
39161 fail:
39162 return NULL;
39163 }
39164
39165
39166 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39167 PyObject *resultobj = 0;
39168 wxWindow *arg1 = (wxWindow *) 0 ;
39169 wxPoint *arg2 = 0 ;
39170 wxPoint result;
39171 void *argp1 = 0 ;
39172 int res1 = 0 ;
39173 wxPoint temp2 ;
39174 PyObject * obj0 = 0 ;
39175 PyObject * obj1 = 0 ;
39176 char * kwnames[] = {
39177 (char *) "self",(char *) "pt", NULL
39178 };
39179
39180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39182 if (!SWIG_IsOK(res1)) {
39183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39184 }
39185 arg1 = reinterpret_cast< wxWindow * >(argp1);
39186 {
39187 arg2 = &temp2;
39188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39189 }
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39193 wxPyEndAllowThreads(__tstate);
39194 if (PyErr_Occurred()) SWIG_fail;
39195 }
39196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39197 return resultobj;
39198 fail:
39199 return NULL;
39200 }
39201
39202
39203 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj = 0;
39205 wxWindow *arg1 = (wxWindow *) 0 ;
39206 int arg2 ;
39207 int arg3 ;
39208 wxHitTest result;
39209 void *argp1 = 0 ;
39210 int res1 = 0 ;
39211 int val2 ;
39212 int ecode2 = 0 ;
39213 int val3 ;
39214 int ecode3 = 0 ;
39215 PyObject * obj0 = 0 ;
39216 PyObject * obj1 = 0 ;
39217 PyObject * obj2 = 0 ;
39218 char * kwnames[] = {
39219 (char *) "self",(char *) "x",(char *) "y", NULL
39220 };
39221
39222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39224 if (!SWIG_IsOK(res1)) {
39225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39226 }
39227 arg1 = reinterpret_cast< wxWindow * >(argp1);
39228 ecode2 = SWIG_AsVal_int(obj1, &val2);
39229 if (!SWIG_IsOK(ecode2)) {
39230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39231 }
39232 arg2 = static_cast< int >(val2);
39233 ecode3 = SWIG_AsVal_int(obj2, &val3);
39234 if (!SWIG_IsOK(ecode3)) {
39235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39236 }
39237 arg3 = static_cast< int >(val3);
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 resultobj = SWIG_From_int(static_cast< int >(result));
39245 return resultobj;
39246 fail:
39247 return NULL;
39248 }
39249
39250
39251 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39252 PyObject *resultobj = 0;
39253 wxWindow *arg1 = (wxWindow *) 0 ;
39254 wxPoint *arg2 = 0 ;
39255 wxHitTest result;
39256 void *argp1 = 0 ;
39257 int res1 = 0 ;
39258 wxPoint temp2 ;
39259 PyObject * obj0 = 0 ;
39260 PyObject * obj1 = 0 ;
39261 char * kwnames[] = {
39262 (char *) "self",(char *) "pt", NULL
39263 };
39264
39265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39269 }
39270 arg1 = reinterpret_cast< wxWindow * >(argp1);
39271 {
39272 arg2 = &temp2;
39273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39274 }
39275 {
39276 PyThreadState* __tstate = wxPyBeginAllowThreads();
39277 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39278 wxPyEndAllowThreads(__tstate);
39279 if (PyErr_Occurred()) SWIG_fail;
39280 }
39281 resultobj = SWIG_From_int(static_cast< int >(result));
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39289 PyObject *resultobj = 0;
39290 wxWindow *arg1 = (wxWindow *) 0 ;
39291 long arg2 ;
39292 wxBorder result;
39293 void *argp1 = 0 ;
39294 int res1 = 0 ;
39295 long val2 ;
39296 int ecode2 = 0 ;
39297
39298 if ((nobjs < 2) || (nobjs > 2)) 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 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39305 if (!SWIG_IsOK(ecode2)) {
39306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39307 }
39308 arg2 = static_cast< long >(val2);
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 resultobj = SWIG_From_int(static_cast< int >(result));
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39323 PyObject *resultobj = 0;
39324 wxWindow *arg1 = (wxWindow *) 0 ;
39325 wxBorder result;
39326 void *argp1 = 0 ;
39327 int res1 = 0 ;
39328
39329 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39331 if (!SWIG_IsOK(res1)) {
39332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39333 }
39334 arg1 = reinterpret_cast< wxWindow * >(argp1);
39335 {
39336 PyThreadState* __tstate = wxPyBeginAllowThreads();
39337 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 resultobj = SWIG_From_int(static_cast< int >(result));
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39349 int argc;
39350 PyObject *argv[3];
39351
39352 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39353 --argc;
39354 if (argc == 1) {
39355 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39356 }
39357 if (argc == 2) {
39358 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39359 }
39360
39361 fail:
39362 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39363 return NULL;
39364 }
39365
39366
39367 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39368 PyObject *resultobj = 0;
39369 wxWindow *arg1 = (wxWindow *) 0 ;
39370 long arg2 = (long) wxUPDATE_UI_NONE ;
39371 void *argp1 = 0 ;
39372 int res1 = 0 ;
39373 long val2 ;
39374 int ecode2 = 0 ;
39375 PyObject * obj0 = 0 ;
39376 PyObject * obj1 = 0 ;
39377 char * kwnames[] = {
39378 (char *) "self",(char *) "flags", NULL
39379 };
39380
39381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39383 if (!SWIG_IsOK(res1)) {
39384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39385 }
39386 arg1 = reinterpret_cast< wxWindow * >(argp1);
39387 if (obj1) {
39388 ecode2 = SWIG_AsVal_long(obj1, &val2);
39389 if (!SWIG_IsOK(ecode2)) {
39390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39391 }
39392 arg2 = static_cast< long >(val2);
39393 }
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 (arg1)->UpdateWindowUI(arg2);
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 resultobj = SWIG_Py_Void();
39401 return resultobj;
39402 fail:
39403 return NULL;
39404 }
39405
39406
39407 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj = 0;
39409 wxWindow *arg1 = (wxWindow *) 0 ;
39410 wxMenu *arg2 = (wxMenu *) 0 ;
39411 int arg3 = (int) -1 ;
39412 int arg4 = (int) -1 ;
39413 bool result;
39414 void *argp1 = 0 ;
39415 int res1 = 0 ;
39416 void *argp2 = 0 ;
39417 int res2 = 0 ;
39418 int val3 ;
39419 int ecode3 = 0 ;
39420 int val4 ;
39421 int ecode4 = 0 ;
39422 PyObject * obj0 = 0 ;
39423 PyObject * obj1 = 0 ;
39424 PyObject * obj2 = 0 ;
39425 PyObject * obj3 = 0 ;
39426 char * kwnames[] = {
39427 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39428 };
39429
39430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39432 if (!SWIG_IsOK(res1)) {
39433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39434 }
39435 arg1 = reinterpret_cast< wxWindow * >(argp1);
39436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res2)) {
39438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39439 }
39440 arg2 = reinterpret_cast< wxMenu * >(argp2);
39441 if (obj2) {
39442 ecode3 = SWIG_AsVal_int(obj2, &val3);
39443 if (!SWIG_IsOK(ecode3)) {
39444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39445 }
39446 arg3 = static_cast< int >(val3);
39447 }
39448 if (obj3) {
39449 ecode4 = SWIG_AsVal_int(obj3, &val4);
39450 if (!SWIG_IsOK(ecode4)) {
39451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39452 }
39453 arg4 = static_cast< int >(val4);
39454 }
39455 {
39456 PyThreadState* __tstate = wxPyBeginAllowThreads();
39457 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39458 wxPyEndAllowThreads(__tstate);
39459 if (PyErr_Occurred()) SWIG_fail;
39460 }
39461 {
39462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39463 }
39464 return resultobj;
39465 fail:
39466 return NULL;
39467 }
39468
39469
39470 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39471 PyObject *resultobj = 0;
39472 wxWindow *arg1 = (wxWindow *) 0 ;
39473 wxMenu *arg2 = (wxMenu *) 0 ;
39474 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39475 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39476 bool result;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 void *argp2 = 0 ;
39480 int res2 = 0 ;
39481 wxPoint temp3 ;
39482 PyObject * obj0 = 0 ;
39483 PyObject * obj1 = 0 ;
39484 PyObject * obj2 = 0 ;
39485 char * kwnames[] = {
39486 (char *) "self",(char *) "menu",(char *) "pos", NULL
39487 };
39488
39489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39491 if (!SWIG_IsOK(res1)) {
39492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39493 }
39494 arg1 = reinterpret_cast< wxWindow * >(argp1);
39495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39496 if (!SWIG_IsOK(res2)) {
39497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39498 }
39499 arg2 = reinterpret_cast< wxMenu * >(argp2);
39500 if (obj2) {
39501 {
39502 arg3 = &temp3;
39503 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39504 }
39505 }
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 {
39513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39514 }
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39522 PyObject *resultobj = 0;
39523 wxWindow *arg1 = (wxWindow *) 0 ;
39524 bool result;
39525 void *argp1 = 0 ;
39526 int res1 = 0 ;
39527 PyObject *swig_obj[1] ;
39528
39529 if (!args) SWIG_fail;
39530 swig_obj[0] = args;
39531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39532 if (!SWIG_IsOK(res1)) {
39533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39534 }
39535 arg1 = reinterpret_cast< wxWindow * >(argp1);
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39539 wxPyEndAllowThreads(__tstate);
39540 if (PyErr_Occurred()) SWIG_fail;
39541 }
39542 {
39543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39544 }
39545 return resultobj;
39546 fail:
39547 return NULL;
39548 }
39549
39550
39551 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39552 PyObject *resultobj = 0;
39553 wxWindow *arg1 = (wxWindow *) 0 ;
39554 long result;
39555 void *argp1 = 0 ;
39556 int res1 = 0 ;
39557 PyObject *swig_obj[1] ;
39558
39559 if (!args) SWIG_fail;
39560 swig_obj[0] = args;
39561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39562 if (!SWIG_IsOK(res1)) {
39563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39564 }
39565 arg1 = reinterpret_cast< wxWindow * >(argp1);
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (long)wxWindow_GetHandle(arg1);
39569 wxPyEndAllowThreads(__tstate);
39570 if (PyErr_Occurred()) SWIG_fail;
39571 }
39572 resultobj = SWIG_From_long(static_cast< long >(result));
39573 return resultobj;
39574 fail:
39575 return NULL;
39576 }
39577
39578
39579 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39580 PyObject *resultobj = 0;
39581 wxWindow *arg1 = (wxWindow *) 0 ;
39582 long arg2 ;
39583 void *argp1 = 0 ;
39584 int res1 = 0 ;
39585 long val2 ;
39586 int ecode2 = 0 ;
39587 PyObject * obj0 = 0 ;
39588 PyObject * obj1 = 0 ;
39589 char * kwnames[] = {
39590 (char *) "self",(char *) "handle", NULL
39591 };
39592
39593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39597 }
39598 arg1 = reinterpret_cast< wxWindow * >(argp1);
39599 ecode2 = SWIG_AsVal_long(obj1, &val2);
39600 if (!SWIG_IsOK(ecode2)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39602 }
39603 arg2 = static_cast< long >(val2);
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 wxWindow_AssociateHandle(arg1,arg2);
39607 wxPyEndAllowThreads(__tstate);
39608 if (PyErr_Occurred()) SWIG_fail;
39609 }
39610 resultobj = SWIG_Py_Void();
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39618 PyObject *resultobj = 0;
39619 wxWindow *arg1 = (wxWindow *) 0 ;
39620 void *argp1 = 0 ;
39621 int res1 = 0 ;
39622 PyObject *swig_obj[1] ;
39623
39624 if (!args) SWIG_fail;
39625 swig_obj[0] = args;
39626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39627 if (!SWIG_IsOK(res1)) {
39628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39629 }
39630 arg1 = reinterpret_cast< wxWindow * >(argp1);
39631 {
39632 PyThreadState* __tstate = wxPyBeginAllowThreads();
39633 (arg1)->DissociateHandle();
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 resultobj = SWIG_Py_Void();
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39645 PyObject *resultobj = 0;
39646 wxWindow *arg1 = (wxWindow *) 0 ;
39647 wxPaintEvent *arg2 = 0 ;
39648 void *argp1 = 0 ;
39649 int res1 = 0 ;
39650 void *argp2 = 0 ;
39651 int res2 = 0 ;
39652 PyObject * obj0 = 0 ;
39653 PyObject * obj1 = 0 ;
39654 char * kwnames[] = {
39655 (char *) "self",(char *) "event", NULL
39656 };
39657
39658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39660 if (!SWIG_IsOK(res1)) {
39661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39662 }
39663 arg1 = reinterpret_cast< wxWindow * >(argp1);
39664 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39665 if (!SWIG_IsOK(res2)) {
39666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39667 }
39668 if (!argp2) {
39669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39670 }
39671 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 (arg1)->OnPaint(*arg2);
39675 wxPyEndAllowThreads(__tstate);
39676 if (PyErr_Occurred()) SWIG_fail;
39677 }
39678 resultobj = SWIG_Py_Void();
39679 return resultobj;
39680 fail:
39681 return NULL;
39682 }
39683
39684
39685 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj = 0;
39687 wxWindow *arg1 = (wxWindow *) 0 ;
39688 int arg2 ;
39689 bool result;
39690 void *argp1 = 0 ;
39691 int res1 = 0 ;
39692 int val2 ;
39693 int ecode2 = 0 ;
39694 PyObject * obj0 = 0 ;
39695 PyObject * obj1 = 0 ;
39696 char * kwnames[] = {
39697 (char *) "self",(char *) "orient", NULL
39698 };
39699
39700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39702 if (!SWIG_IsOK(res1)) {
39703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39704 }
39705 arg1 = reinterpret_cast< wxWindow * >(argp1);
39706 ecode2 = SWIG_AsVal_int(obj1, &val2);
39707 if (!SWIG_IsOK(ecode2)) {
39708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39709 }
39710 arg2 = static_cast< int >(val2);
39711 {
39712 PyThreadState* __tstate = wxPyBeginAllowThreads();
39713 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 {
39718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39719 }
39720 return resultobj;
39721 fail:
39722 return NULL;
39723 }
39724
39725
39726 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39727 PyObject *resultobj = 0;
39728 wxWindow *arg1 = (wxWindow *) 0 ;
39729 int arg2 ;
39730 int arg3 ;
39731 int arg4 ;
39732 int arg5 ;
39733 bool arg6 = (bool) true ;
39734 void *argp1 = 0 ;
39735 int res1 = 0 ;
39736 int val2 ;
39737 int ecode2 = 0 ;
39738 int val3 ;
39739 int ecode3 = 0 ;
39740 int val4 ;
39741 int ecode4 = 0 ;
39742 int val5 ;
39743 int ecode5 = 0 ;
39744 bool val6 ;
39745 int ecode6 = 0 ;
39746 PyObject * obj0 = 0 ;
39747 PyObject * obj1 = 0 ;
39748 PyObject * obj2 = 0 ;
39749 PyObject * obj3 = 0 ;
39750 PyObject * obj4 = 0 ;
39751 PyObject * obj5 = 0 ;
39752 char * kwnames[] = {
39753 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39754 };
39755
39756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39758 if (!SWIG_IsOK(res1)) {
39759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39760 }
39761 arg1 = reinterpret_cast< wxWindow * >(argp1);
39762 ecode2 = SWIG_AsVal_int(obj1, &val2);
39763 if (!SWIG_IsOK(ecode2)) {
39764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39765 }
39766 arg2 = static_cast< int >(val2);
39767 ecode3 = SWIG_AsVal_int(obj2, &val3);
39768 if (!SWIG_IsOK(ecode3)) {
39769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39770 }
39771 arg3 = static_cast< int >(val3);
39772 ecode4 = SWIG_AsVal_int(obj3, &val4);
39773 if (!SWIG_IsOK(ecode4)) {
39774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39775 }
39776 arg4 = static_cast< int >(val4);
39777 ecode5 = SWIG_AsVal_int(obj4, &val5);
39778 if (!SWIG_IsOK(ecode5)) {
39779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39780 }
39781 arg5 = static_cast< int >(val5);
39782 if (obj5) {
39783 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39784 if (!SWIG_IsOK(ecode6)) {
39785 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39786 }
39787 arg6 = static_cast< bool >(val6);
39788 }
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 resultobj = SWIG_Py_Void();
39796 return resultobj;
39797 fail:
39798 return NULL;
39799 }
39800
39801
39802 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39803 PyObject *resultobj = 0;
39804 wxWindow *arg1 = (wxWindow *) 0 ;
39805 int arg2 ;
39806 int arg3 ;
39807 bool arg4 = (bool) true ;
39808 void *argp1 = 0 ;
39809 int res1 = 0 ;
39810 int val2 ;
39811 int ecode2 = 0 ;
39812 int val3 ;
39813 int ecode3 = 0 ;
39814 bool val4 ;
39815 int ecode4 = 0 ;
39816 PyObject * obj0 = 0 ;
39817 PyObject * obj1 = 0 ;
39818 PyObject * obj2 = 0 ;
39819 PyObject * obj3 = 0 ;
39820 char * kwnames[] = {
39821 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39822 };
39823
39824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39826 if (!SWIG_IsOK(res1)) {
39827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39828 }
39829 arg1 = reinterpret_cast< wxWindow * >(argp1);
39830 ecode2 = SWIG_AsVal_int(obj1, &val2);
39831 if (!SWIG_IsOK(ecode2)) {
39832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39833 }
39834 arg2 = static_cast< int >(val2);
39835 ecode3 = SWIG_AsVal_int(obj2, &val3);
39836 if (!SWIG_IsOK(ecode3)) {
39837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39838 }
39839 arg3 = static_cast< int >(val3);
39840 if (obj3) {
39841 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39842 if (!SWIG_IsOK(ecode4)) {
39843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39844 }
39845 arg4 = static_cast< bool >(val4);
39846 }
39847 {
39848 PyThreadState* __tstate = wxPyBeginAllowThreads();
39849 (arg1)->SetScrollPos(arg2,arg3,arg4);
39850 wxPyEndAllowThreads(__tstate);
39851 if (PyErr_Occurred()) SWIG_fail;
39852 }
39853 resultobj = SWIG_Py_Void();
39854 return resultobj;
39855 fail:
39856 return NULL;
39857 }
39858
39859
39860 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39861 PyObject *resultobj = 0;
39862 wxWindow *arg1 = (wxWindow *) 0 ;
39863 int arg2 ;
39864 int result;
39865 void *argp1 = 0 ;
39866 int res1 = 0 ;
39867 int val2 ;
39868 int ecode2 = 0 ;
39869 PyObject * obj0 = 0 ;
39870 PyObject * obj1 = 0 ;
39871 char * kwnames[] = {
39872 (char *) "self",(char *) "orientation", NULL
39873 };
39874
39875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39877 if (!SWIG_IsOK(res1)) {
39878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39879 }
39880 arg1 = reinterpret_cast< wxWindow * >(argp1);
39881 ecode2 = SWIG_AsVal_int(obj1, &val2);
39882 if (!SWIG_IsOK(ecode2)) {
39883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39884 }
39885 arg2 = static_cast< int >(val2);
39886 {
39887 PyThreadState* __tstate = wxPyBeginAllowThreads();
39888 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39889 wxPyEndAllowThreads(__tstate);
39890 if (PyErr_Occurred()) SWIG_fail;
39891 }
39892 resultobj = SWIG_From_int(static_cast< int >(result));
39893 return resultobj;
39894 fail:
39895 return NULL;
39896 }
39897
39898
39899 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39900 PyObject *resultobj = 0;
39901 wxWindow *arg1 = (wxWindow *) 0 ;
39902 int arg2 ;
39903 int result;
39904 void *argp1 = 0 ;
39905 int res1 = 0 ;
39906 int val2 ;
39907 int ecode2 = 0 ;
39908 PyObject * obj0 = 0 ;
39909 PyObject * obj1 = 0 ;
39910 char * kwnames[] = {
39911 (char *) "self",(char *) "orientation", NULL
39912 };
39913
39914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39916 if (!SWIG_IsOK(res1)) {
39917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39918 }
39919 arg1 = reinterpret_cast< wxWindow * >(argp1);
39920 ecode2 = SWIG_AsVal_int(obj1, &val2);
39921 if (!SWIG_IsOK(ecode2)) {
39922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39923 }
39924 arg2 = static_cast< int >(val2);
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 resultobj = SWIG_From_int(static_cast< int >(result));
39932 return resultobj;
39933 fail:
39934 return NULL;
39935 }
39936
39937
39938 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39939 PyObject *resultobj = 0;
39940 wxWindow *arg1 = (wxWindow *) 0 ;
39941 int arg2 ;
39942 int result;
39943 void *argp1 = 0 ;
39944 int res1 = 0 ;
39945 int val2 ;
39946 int ecode2 = 0 ;
39947 PyObject * obj0 = 0 ;
39948 PyObject * obj1 = 0 ;
39949 char * kwnames[] = {
39950 (char *) "self",(char *) "orientation", NULL
39951 };
39952
39953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39955 if (!SWIG_IsOK(res1)) {
39956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39957 }
39958 arg1 = reinterpret_cast< wxWindow * >(argp1);
39959 ecode2 = SWIG_AsVal_int(obj1, &val2);
39960 if (!SWIG_IsOK(ecode2)) {
39961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39962 }
39963 arg2 = static_cast< int >(val2);
39964 {
39965 PyThreadState* __tstate = wxPyBeginAllowThreads();
39966 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39967 wxPyEndAllowThreads(__tstate);
39968 if (PyErr_Occurred()) SWIG_fail;
39969 }
39970 resultobj = SWIG_From_int(static_cast< int >(result));
39971 return resultobj;
39972 fail:
39973 return NULL;
39974 }
39975
39976
39977 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39978 PyObject *resultobj = 0;
39979 wxWindow *arg1 = (wxWindow *) 0 ;
39980 int arg2 ;
39981 int arg3 ;
39982 wxRect *arg4 = (wxRect *) NULL ;
39983 void *argp1 = 0 ;
39984 int res1 = 0 ;
39985 int val2 ;
39986 int ecode2 = 0 ;
39987 int val3 ;
39988 int ecode3 = 0 ;
39989 void *argp4 = 0 ;
39990 int res4 = 0 ;
39991 PyObject * obj0 = 0 ;
39992 PyObject * obj1 = 0 ;
39993 PyObject * obj2 = 0 ;
39994 PyObject * obj3 = 0 ;
39995 char * kwnames[] = {
39996 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39997 };
39998
39999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40001 if (!SWIG_IsOK(res1)) {
40002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40003 }
40004 arg1 = reinterpret_cast< wxWindow * >(argp1);
40005 ecode2 = SWIG_AsVal_int(obj1, &val2);
40006 if (!SWIG_IsOK(ecode2)) {
40007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40008 }
40009 arg2 = static_cast< int >(val2);
40010 ecode3 = SWIG_AsVal_int(obj2, &val3);
40011 if (!SWIG_IsOK(ecode3)) {
40012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40013 }
40014 arg3 = static_cast< int >(val3);
40015 if (obj3) {
40016 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40017 if (!SWIG_IsOK(res4)) {
40018 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40019 }
40020 arg4 = reinterpret_cast< wxRect * >(argp4);
40021 }
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40025 wxPyEndAllowThreads(__tstate);
40026 if (PyErr_Occurred()) SWIG_fail;
40027 }
40028 resultobj = SWIG_Py_Void();
40029 return resultobj;
40030 fail:
40031 return NULL;
40032 }
40033
40034
40035 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40036 PyObject *resultobj = 0;
40037 wxWindow *arg1 = (wxWindow *) 0 ;
40038 int arg2 ;
40039 bool result;
40040 void *argp1 = 0 ;
40041 int res1 = 0 ;
40042 int val2 ;
40043 int ecode2 = 0 ;
40044 PyObject * obj0 = 0 ;
40045 PyObject * obj1 = 0 ;
40046 char * kwnames[] = {
40047 (char *) "self",(char *) "lines", NULL
40048 };
40049
40050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40052 if (!SWIG_IsOK(res1)) {
40053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40054 }
40055 arg1 = reinterpret_cast< wxWindow * >(argp1);
40056 ecode2 = SWIG_AsVal_int(obj1, &val2);
40057 if (!SWIG_IsOK(ecode2)) {
40058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40059 }
40060 arg2 = static_cast< int >(val2);
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 result = (bool)(arg1)->ScrollLines(arg2);
40064 wxPyEndAllowThreads(__tstate);
40065 if (PyErr_Occurred()) SWIG_fail;
40066 }
40067 {
40068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40069 }
40070 return resultobj;
40071 fail:
40072 return NULL;
40073 }
40074
40075
40076 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40077 PyObject *resultobj = 0;
40078 wxWindow *arg1 = (wxWindow *) 0 ;
40079 int arg2 ;
40080 bool result;
40081 void *argp1 = 0 ;
40082 int res1 = 0 ;
40083 int val2 ;
40084 int ecode2 = 0 ;
40085 PyObject * obj0 = 0 ;
40086 PyObject * obj1 = 0 ;
40087 char * kwnames[] = {
40088 (char *) "self",(char *) "pages", NULL
40089 };
40090
40091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40093 if (!SWIG_IsOK(res1)) {
40094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40095 }
40096 arg1 = reinterpret_cast< wxWindow * >(argp1);
40097 ecode2 = SWIG_AsVal_int(obj1, &val2);
40098 if (!SWIG_IsOK(ecode2)) {
40099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40100 }
40101 arg2 = static_cast< int >(val2);
40102 {
40103 PyThreadState* __tstate = wxPyBeginAllowThreads();
40104 result = (bool)(arg1)->ScrollPages(arg2);
40105 wxPyEndAllowThreads(__tstate);
40106 if (PyErr_Occurred()) SWIG_fail;
40107 }
40108 {
40109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40110 }
40111 return resultobj;
40112 fail:
40113 return NULL;
40114 }
40115
40116
40117 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40118 PyObject *resultobj = 0;
40119 wxWindow *arg1 = (wxWindow *) 0 ;
40120 bool result;
40121 void *argp1 = 0 ;
40122 int res1 = 0 ;
40123 PyObject *swig_obj[1] ;
40124
40125 if (!args) SWIG_fail;
40126 swig_obj[0] = args;
40127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40130 }
40131 arg1 = reinterpret_cast< wxWindow * >(argp1);
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 result = (bool)(arg1)->LineUp();
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 {
40139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40140 }
40141 return resultobj;
40142 fail:
40143 return NULL;
40144 }
40145
40146
40147 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40148 PyObject *resultobj = 0;
40149 wxWindow *arg1 = (wxWindow *) 0 ;
40150 bool result;
40151 void *argp1 = 0 ;
40152 int res1 = 0 ;
40153 PyObject *swig_obj[1] ;
40154
40155 if (!args) SWIG_fail;
40156 swig_obj[0] = args;
40157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40160 }
40161 arg1 = reinterpret_cast< wxWindow * >(argp1);
40162 {
40163 PyThreadState* __tstate = wxPyBeginAllowThreads();
40164 result = (bool)(arg1)->LineDown();
40165 wxPyEndAllowThreads(__tstate);
40166 if (PyErr_Occurred()) SWIG_fail;
40167 }
40168 {
40169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40170 }
40171 return resultobj;
40172 fail:
40173 return NULL;
40174 }
40175
40176
40177 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40178 PyObject *resultobj = 0;
40179 wxWindow *arg1 = (wxWindow *) 0 ;
40180 bool result;
40181 void *argp1 = 0 ;
40182 int res1 = 0 ;
40183 PyObject *swig_obj[1] ;
40184
40185 if (!args) SWIG_fail;
40186 swig_obj[0] = args;
40187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40190 }
40191 arg1 = reinterpret_cast< wxWindow * >(argp1);
40192 {
40193 PyThreadState* __tstate = wxPyBeginAllowThreads();
40194 result = (bool)(arg1)->PageUp();
40195 wxPyEndAllowThreads(__tstate);
40196 if (PyErr_Occurred()) SWIG_fail;
40197 }
40198 {
40199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40200 }
40201 return resultobj;
40202 fail:
40203 return NULL;
40204 }
40205
40206
40207 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40208 PyObject *resultobj = 0;
40209 wxWindow *arg1 = (wxWindow *) 0 ;
40210 bool result;
40211 void *argp1 = 0 ;
40212 int res1 = 0 ;
40213 PyObject *swig_obj[1] ;
40214
40215 if (!args) SWIG_fail;
40216 swig_obj[0] = args;
40217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40218 if (!SWIG_IsOK(res1)) {
40219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40220 }
40221 arg1 = reinterpret_cast< wxWindow * >(argp1);
40222 {
40223 PyThreadState* __tstate = wxPyBeginAllowThreads();
40224 result = (bool)(arg1)->PageDown();
40225 wxPyEndAllowThreads(__tstate);
40226 if (PyErr_Occurred()) SWIG_fail;
40227 }
40228 {
40229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40230 }
40231 return resultobj;
40232 fail:
40233 return NULL;
40234 }
40235
40236
40237 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40238 PyObject *resultobj = 0;
40239 wxWindow *arg1 = (wxWindow *) 0 ;
40240 wxString *arg2 = 0 ;
40241 void *argp1 = 0 ;
40242 int res1 = 0 ;
40243 bool temp2 = false ;
40244 PyObject * obj0 = 0 ;
40245 PyObject * obj1 = 0 ;
40246 char * kwnames[] = {
40247 (char *) "self",(char *) "text", NULL
40248 };
40249
40250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40252 if (!SWIG_IsOK(res1)) {
40253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40254 }
40255 arg1 = reinterpret_cast< wxWindow * >(argp1);
40256 {
40257 arg2 = wxString_in_helper(obj1);
40258 if (arg2 == NULL) SWIG_fail;
40259 temp2 = true;
40260 }
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->SetHelpText((wxString const &)*arg2);
40264 wxPyEndAllowThreads(__tstate);
40265 if (PyErr_Occurred()) SWIG_fail;
40266 }
40267 resultobj = SWIG_Py_Void();
40268 {
40269 if (temp2)
40270 delete arg2;
40271 }
40272 return resultobj;
40273 fail:
40274 {
40275 if (temp2)
40276 delete arg2;
40277 }
40278 return NULL;
40279 }
40280
40281
40282 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40283 PyObject *resultobj = 0;
40284 wxWindow *arg1 = (wxWindow *) 0 ;
40285 wxString *arg2 = 0 ;
40286 void *argp1 = 0 ;
40287 int res1 = 0 ;
40288 bool temp2 = false ;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char * kwnames[] = {
40292 (char *) "self",(char *) "text", NULL
40293 };
40294
40295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40297 if (!SWIG_IsOK(res1)) {
40298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40299 }
40300 arg1 = reinterpret_cast< wxWindow * >(argp1);
40301 {
40302 arg2 = wxString_in_helper(obj1);
40303 if (arg2 == NULL) SWIG_fail;
40304 temp2 = true;
40305 }
40306 {
40307 PyThreadState* __tstate = wxPyBeginAllowThreads();
40308 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40309 wxPyEndAllowThreads(__tstate);
40310 if (PyErr_Occurred()) SWIG_fail;
40311 }
40312 resultobj = SWIG_Py_Void();
40313 {
40314 if (temp2)
40315 delete arg2;
40316 }
40317 return resultobj;
40318 fail:
40319 {
40320 if (temp2)
40321 delete arg2;
40322 }
40323 return NULL;
40324 }
40325
40326
40327 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40328 PyObject *resultobj = 0;
40329 wxWindow *arg1 = (wxWindow *) 0 ;
40330 wxPoint *arg2 = 0 ;
40331 wxHelpEvent::Origin arg3 ;
40332 wxString result;
40333 void *argp1 = 0 ;
40334 int res1 = 0 ;
40335 wxPoint temp2 ;
40336 void *argp3 ;
40337 int res3 = 0 ;
40338 PyObject * obj0 = 0 ;
40339 PyObject * obj1 = 0 ;
40340 PyObject * obj2 = 0 ;
40341 char * kwnames[] = {
40342 (char *) "self",(char *) "pt",(char *) "origin", NULL
40343 };
40344
40345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40347 if (!SWIG_IsOK(res1)) {
40348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40349 }
40350 arg1 = reinterpret_cast< wxWindow * >(argp1);
40351 {
40352 arg2 = &temp2;
40353 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40354 }
40355 {
40356 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40357 if (!SWIG_IsOK(res3)) {
40358 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40359 }
40360 if (!argp3) {
40361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40362 } else {
40363 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40364 arg3 = *temp;
40365 if (SWIG_IsNewObj(res3)) delete temp;
40366 }
40367 }
40368 {
40369 PyThreadState* __tstate = wxPyBeginAllowThreads();
40370 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40371 wxPyEndAllowThreads(__tstate);
40372 if (PyErr_Occurred()) SWIG_fail;
40373 }
40374 {
40375 #if wxUSE_UNICODE
40376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40377 #else
40378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40379 #endif
40380 }
40381 return resultobj;
40382 fail:
40383 return NULL;
40384 }
40385
40386
40387 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40388 PyObject *resultobj = 0;
40389 wxWindow *arg1 = (wxWindow *) 0 ;
40390 wxString result;
40391 void *argp1 = 0 ;
40392 int res1 = 0 ;
40393 PyObject *swig_obj[1] ;
40394
40395 if (!args) SWIG_fail;
40396 swig_obj[0] = args;
40397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40398 if (!SWIG_IsOK(res1)) {
40399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40400 }
40401 arg1 = reinterpret_cast< wxWindow * >(argp1);
40402 {
40403 PyThreadState* __tstate = wxPyBeginAllowThreads();
40404 result = ((wxWindow const *)arg1)->GetHelpText();
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 {
40409 #if wxUSE_UNICODE
40410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40411 #else
40412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40413 #endif
40414 }
40415 return resultobj;
40416 fail:
40417 return NULL;
40418 }
40419
40420
40421 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40422 PyObject *resultobj = 0;
40423 wxWindow *arg1 = (wxWindow *) 0 ;
40424 wxString *arg2 = 0 ;
40425 void *argp1 = 0 ;
40426 int res1 = 0 ;
40427 bool temp2 = false ;
40428 PyObject * obj0 = 0 ;
40429 PyObject * obj1 = 0 ;
40430 char * kwnames[] = {
40431 (char *) "self",(char *) "tip", NULL
40432 };
40433
40434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40436 if (!SWIG_IsOK(res1)) {
40437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40438 }
40439 arg1 = reinterpret_cast< wxWindow * >(argp1);
40440 {
40441 arg2 = wxString_in_helper(obj1);
40442 if (arg2 == NULL) SWIG_fail;
40443 temp2 = true;
40444 }
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 (arg1)->SetToolTip((wxString const &)*arg2);
40448 wxPyEndAllowThreads(__tstate);
40449 if (PyErr_Occurred()) SWIG_fail;
40450 }
40451 resultobj = SWIG_Py_Void();
40452 {
40453 if (temp2)
40454 delete arg2;
40455 }
40456 return resultobj;
40457 fail:
40458 {
40459 if (temp2)
40460 delete arg2;
40461 }
40462 return NULL;
40463 }
40464
40465
40466 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj = 0;
40468 wxWindow *arg1 = (wxWindow *) 0 ;
40469 wxToolTip *arg2 = (wxToolTip *) 0 ;
40470 void *argp1 = 0 ;
40471 int res1 = 0 ;
40472 int res2 = 0 ;
40473 PyObject * obj0 = 0 ;
40474 PyObject * obj1 = 0 ;
40475 char * kwnames[] = {
40476 (char *) "self",(char *) "tip", NULL
40477 };
40478
40479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40481 if (!SWIG_IsOK(res1)) {
40482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40483 }
40484 arg1 = reinterpret_cast< wxWindow * >(argp1);
40485 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40486 if (!SWIG_IsOK(res2)) {
40487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40488 }
40489 {
40490 PyThreadState* __tstate = wxPyBeginAllowThreads();
40491 (arg1)->SetToolTip(arg2);
40492 wxPyEndAllowThreads(__tstate);
40493 if (PyErr_Occurred()) SWIG_fail;
40494 }
40495 resultobj = SWIG_Py_Void();
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40503 PyObject *resultobj = 0;
40504 wxWindow *arg1 = (wxWindow *) 0 ;
40505 wxToolTip *result = 0 ;
40506 void *argp1 = 0 ;
40507 int res1 = 0 ;
40508 PyObject *swig_obj[1] ;
40509
40510 if (!args) SWIG_fail;
40511 swig_obj[0] = args;
40512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40515 }
40516 arg1 = reinterpret_cast< wxWindow * >(argp1);
40517 {
40518 PyThreadState* __tstate = wxPyBeginAllowThreads();
40519 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 {
40524 resultobj = wxPyMake_wxObject(result, (bool)0);
40525 }
40526 return resultobj;
40527 fail:
40528 return NULL;
40529 }
40530
40531
40532 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40533 PyObject *resultobj = 0;
40534 wxWindow *arg1 = (wxWindow *) 0 ;
40535 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40536 void *argp1 = 0 ;
40537 int res1 = 0 ;
40538 int res2 = 0 ;
40539 PyObject * obj0 = 0 ;
40540 PyObject * obj1 = 0 ;
40541 char * kwnames[] = {
40542 (char *) "self",(char *) "dropTarget", NULL
40543 };
40544
40545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40547 if (!SWIG_IsOK(res1)) {
40548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40549 }
40550 arg1 = reinterpret_cast< wxWindow * >(argp1);
40551 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40552 if (!SWIG_IsOK(res2)) {
40553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40554 }
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 (arg1)->SetDropTarget(arg2);
40558 wxPyEndAllowThreads(__tstate);
40559 if (PyErr_Occurred()) SWIG_fail;
40560 }
40561 resultobj = SWIG_Py_Void();
40562 return resultobj;
40563 fail:
40564 return NULL;
40565 }
40566
40567
40568 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40569 PyObject *resultobj = 0;
40570 wxWindow *arg1 = (wxWindow *) 0 ;
40571 wxPyDropTarget *result = 0 ;
40572 void *argp1 = 0 ;
40573 int res1 = 0 ;
40574 PyObject *swig_obj[1] ;
40575
40576 if (!args) SWIG_fail;
40577 swig_obj[0] = args;
40578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40579 if (!SWIG_IsOK(res1)) {
40580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40581 }
40582 arg1 = reinterpret_cast< wxWindow * >(argp1);
40583 {
40584 PyThreadState* __tstate = wxPyBeginAllowThreads();
40585 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40586 wxPyEndAllowThreads(__tstate);
40587 if (PyErr_Occurred()) SWIG_fail;
40588 }
40589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40590 return resultobj;
40591 fail:
40592 return NULL;
40593 }
40594
40595
40596 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40597 PyObject *resultobj = 0;
40598 wxWindow *arg1 = (wxWindow *) 0 ;
40599 bool arg2 ;
40600 void *argp1 = 0 ;
40601 int res1 = 0 ;
40602 bool val2 ;
40603 int ecode2 = 0 ;
40604 PyObject * obj0 = 0 ;
40605 PyObject * obj1 = 0 ;
40606 char * kwnames[] = {
40607 (char *) "self",(char *) "accept", NULL
40608 };
40609
40610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40612 if (!SWIG_IsOK(res1)) {
40613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40614 }
40615 arg1 = reinterpret_cast< wxWindow * >(argp1);
40616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40617 if (!SWIG_IsOK(ecode2)) {
40618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40619 }
40620 arg2 = static_cast< bool >(val2);
40621 {
40622 PyThreadState* __tstate = wxPyBeginAllowThreads();
40623 (arg1)->DragAcceptFiles(arg2);
40624 wxPyEndAllowThreads(__tstate);
40625 if (PyErr_Occurred()) SWIG_fail;
40626 }
40627 resultobj = SWIG_Py_Void();
40628 return resultobj;
40629 fail:
40630 return NULL;
40631 }
40632
40633
40634 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40635 PyObject *resultobj = 0;
40636 wxWindow *arg1 = (wxWindow *) 0 ;
40637 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40638 void *argp1 = 0 ;
40639 int res1 = 0 ;
40640 int res2 = 0 ;
40641 PyObject * obj0 = 0 ;
40642 PyObject * obj1 = 0 ;
40643 char * kwnames[] = {
40644 (char *) "self",(char *) "constraints", NULL
40645 };
40646
40647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40649 if (!SWIG_IsOK(res1)) {
40650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40651 }
40652 arg1 = reinterpret_cast< wxWindow * >(argp1);
40653 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40654 if (!SWIG_IsOK(res2)) {
40655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40656 }
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 (arg1)->SetConstraints(arg2);
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 resultobj = SWIG_Py_Void();
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40671 PyObject *resultobj = 0;
40672 wxWindow *arg1 = (wxWindow *) 0 ;
40673 wxLayoutConstraints *result = 0 ;
40674 void *argp1 = 0 ;
40675 int res1 = 0 ;
40676 PyObject *swig_obj[1] ;
40677
40678 if (!args) SWIG_fail;
40679 swig_obj[0] = args;
40680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40681 if (!SWIG_IsOK(res1)) {
40682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40683 }
40684 arg1 = reinterpret_cast< wxWindow * >(argp1);
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40692 return resultobj;
40693 fail:
40694 return NULL;
40695 }
40696
40697
40698 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40699 PyObject *resultobj = 0;
40700 wxWindow *arg1 = (wxWindow *) 0 ;
40701 bool arg2 ;
40702 void *argp1 = 0 ;
40703 int res1 = 0 ;
40704 bool val2 ;
40705 int ecode2 = 0 ;
40706 PyObject * obj0 = 0 ;
40707 PyObject * obj1 = 0 ;
40708 char * kwnames[] = {
40709 (char *) "self",(char *) "autoLayout", NULL
40710 };
40711
40712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40714 if (!SWIG_IsOK(res1)) {
40715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40716 }
40717 arg1 = reinterpret_cast< wxWindow * >(argp1);
40718 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40719 if (!SWIG_IsOK(ecode2)) {
40720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40721 }
40722 arg2 = static_cast< bool >(val2);
40723 {
40724 PyThreadState* __tstate = wxPyBeginAllowThreads();
40725 (arg1)->SetAutoLayout(arg2);
40726 wxPyEndAllowThreads(__tstate);
40727 if (PyErr_Occurred()) SWIG_fail;
40728 }
40729 resultobj = SWIG_Py_Void();
40730 return resultobj;
40731 fail:
40732 return NULL;
40733 }
40734
40735
40736 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40737 PyObject *resultobj = 0;
40738 wxWindow *arg1 = (wxWindow *) 0 ;
40739 bool result;
40740 void *argp1 = 0 ;
40741 int res1 = 0 ;
40742 PyObject *swig_obj[1] ;
40743
40744 if (!args) SWIG_fail;
40745 swig_obj[0] = args;
40746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40747 if (!SWIG_IsOK(res1)) {
40748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40749 }
40750 arg1 = reinterpret_cast< wxWindow * >(argp1);
40751 {
40752 PyThreadState* __tstate = wxPyBeginAllowThreads();
40753 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40754 wxPyEndAllowThreads(__tstate);
40755 if (PyErr_Occurred()) SWIG_fail;
40756 }
40757 {
40758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40759 }
40760 return resultobj;
40761 fail:
40762 return NULL;
40763 }
40764
40765
40766 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40767 PyObject *resultobj = 0;
40768 wxWindow *arg1 = (wxWindow *) 0 ;
40769 bool result;
40770 void *argp1 = 0 ;
40771 int res1 = 0 ;
40772 PyObject *swig_obj[1] ;
40773
40774 if (!args) SWIG_fail;
40775 swig_obj[0] = args;
40776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40777 if (!SWIG_IsOK(res1)) {
40778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40779 }
40780 arg1 = reinterpret_cast< wxWindow * >(argp1);
40781 {
40782 PyThreadState* __tstate = wxPyBeginAllowThreads();
40783 result = (bool)(arg1)->Layout();
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 {
40788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40789 }
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40797 PyObject *resultobj = 0;
40798 wxWindow *arg1 = (wxWindow *) 0 ;
40799 wxSizer *arg2 = (wxSizer *) 0 ;
40800 bool arg3 = (bool) true ;
40801 void *argp1 = 0 ;
40802 int res1 = 0 ;
40803 int res2 = 0 ;
40804 bool val3 ;
40805 int ecode3 = 0 ;
40806 PyObject * obj0 = 0 ;
40807 PyObject * obj1 = 0 ;
40808 PyObject * obj2 = 0 ;
40809 char * kwnames[] = {
40810 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40811 };
40812
40813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40817 }
40818 arg1 = reinterpret_cast< wxWindow * >(argp1);
40819 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40820 if (!SWIG_IsOK(res2)) {
40821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40822 }
40823 if (obj2) {
40824 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40825 if (!SWIG_IsOK(ecode3)) {
40826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40827 }
40828 arg3 = static_cast< bool >(val3);
40829 }
40830 {
40831 PyThreadState* __tstate = wxPyBeginAllowThreads();
40832 (arg1)->SetSizer(arg2,arg3);
40833 wxPyEndAllowThreads(__tstate);
40834 if (PyErr_Occurred()) SWIG_fail;
40835 }
40836 resultobj = SWIG_Py_Void();
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40844 PyObject *resultobj = 0;
40845 wxWindow *arg1 = (wxWindow *) 0 ;
40846 wxSizer *arg2 = (wxSizer *) 0 ;
40847 bool arg3 = (bool) true ;
40848 void *argp1 = 0 ;
40849 int res1 = 0 ;
40850 int res2 = 0 ;
40851 bool val3 ;
40852 int ecode3 = 0 ;
40853 PyObject * obj0 = 0 ;
40854 PyObject * obj1 = 0 ;
40855 PyObject * obj2 = 0 ;
40856 char * kwnames[] = {
40857 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40858 };
40859
40860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40862 if (!SWIG_IsOK(res1)) {
40863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40864 }
40865 arg1 = reinterpret_cast< wxWindow * >(argp1);
40866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40867 if (!SWIG_IsOK(res2)) {
40868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40869 }
40870 if (obj2) {
40871 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40872 if (!SWIG_IsOK(ecode3)) {
40873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40874 }
40875 arg3 = static_cast< bool >(val3);
40876 }
40877 {
40878 PyThreadState* __tstate = wxPyBeginAllowThreads();
40879 (arg1)->SetSizerAndFit(arg2,arg3);
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 resultobj = SWIG_Py_Void();
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40891 PyObject *resultobj = 0;
40892 wxWindow *arg1 = (wxWindow *) 0 ;
40893 wxSizer *result = 0 ;
40894 void *argp1 = 0 ;
40895 int res1 = 0 ;
40896 PyObject *swig_obj[1] ;
40897
40898 if (!args) SWIG_fail;
40899 swig_obj[0] = args;
40900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40901 if (!SWIG_IsOK(res1)) {
40902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40903 }
40904 arg1 = reinterpret_cast< wxWindow * >(argp1);
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 {
40912 resultobj = wxPyMake_wxObject(result, (bool)0);
40913 }
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj = 0;
40922 wxWindow *arg1 = (wxWindow *) 0 ;
40923 wxSizer *arg2 = (wxSizer *) 0 ;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 void *argp2 = 0 ;
40927 int res2 = 0 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char * kwnames[] = {
40931 (char *) "self",(char *) "sizer", NULL
40932 };
40933
40934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40936 if (!SWIG_IsOK(res1)) {
40937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40938 }
40939 arg1 = reinterpret_cast< wxWindow * >(argp1);
40940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40941 if (!SWIG_IsOK(res2)) {
40942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40943 }
40944 arg2 = reinterpret_cast< wxSizer * >(argp2);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 (arg1)->SetContainingSizer(arg2);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 resultobj = SWIG_Py_Void();
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40959 PyObject *resultobj = 0;
40960 wxWindow *arg1 = (wxWindow *) 0 ;
40961 wxSizer *result = 0 ;
40962 void *argp1 = 0 ;
40963 int res1 = 0 ;
40964 PyObject *swig_obj[1] ;
40965
40966 if (!args) SWIG_fail;
40967 swig_obj[0] = args;
40968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40969 if (!SWIG_IsOK(res1)) {
40970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40971 }
40972 arg1 = reinterpret_cast< wxWindow * >(argp1);
40973 {
40974 PyThreadState* __tstate = wxPyBeginAllowThreads();
40975 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40976 wxPyEndAllowThreads(__tstate);
40977 if (PyErr_Occurred()) SWIG_fail;
40978 }
40979 {
40980 resultobj = wxPyMake_wxObject(result, (bool)0);
40981 }
40982 return resultobj;
40983 fail:
40984 return NULL;
40985 }
40986
40987
40988 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40989 PyObject *resultobj = 0;
40990 wxWindow *arg1 = (wxWindow *) 0 ;
40991 void *argp1 = 0 ;
40992 int res1 = 0 ;
40993 PyObject *swig_obj[1] ;
40994
40995 if (!args) SWIG_fail;
40996 swig_obj[0] = args;
40997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41000 }
41001 arg1 = reinterpret_cast< wxWindow * >(argp1);
41002 {
41003 PyThreadState* __tstate = wxPyBeginAllowThreads();
41004 (arg1)->InheritAttributes();
41005 wxPyEndAllowThreads(__tstate);
41006 if (PyErr_Occurred()) SWIG_fail;
41007 }
41008 resultobj = SWIG_Py_Void();
41009 return resultobj;
41010 fail:
41011 return NULL;
41012 }
41013
41014
41015 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41016 PyObject *resultobj = 0;
41017 wxWindow *arg1 = (wxWindow *) 0 ;
41018 bool result;
41019 void *argp1 = 0 ;
41020 int res1 = 0 ;
41021 PyObject *swig_obj[1] ;
41022
41023 if (!args) SWIG_fail;
41024 swig_obj[0] = args;
41025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41026 if (!SWIG_IsOK(res1)) {
41027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41028 }
41029 arg1 = reinterpret_cast< wxWindow * >(argp1);
41030 {
41031 PyThreadState* __tstate = wxPyBeginAllowThreads();
41032 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41033 wxPyEndAllowThreads(__tstate);
41034 if (PyErr_Occurred()) SWIG_fail;
41035 }
41036 {
41037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41038 }
41039 return resultobj;
41040 fail:
41041 return NULL;
41042 }
41043
41044
41045 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41046 PyObject *resultobj = 0;
41047 wxWindow *arg1 = (wxWindow *) 0 ;
41048 bool result;
41049 void *argp1 = 0 ;
41050 int res1 = 0 ;
41051 PyObject *swig_obj[1] ;
41052
41053 if (!args) SWIG_fail;
41054 swig_obj[0] = args;
41055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41056 if (!SWIG_IsOK(res1)) {
41057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41058 }
41059 arg1 = reinterpret_cast< wxWindow * >(argp1);
41060 {
41061 PyThreadState* __tstate = wxPyBeginAllowThreads();
41062 result = (bool)(arg1)->CanSetTransparent();
41063 wxPyEndAllowThreads(__tstate);
41064 if (PyErr_Occurred()) SWIG_fail;
41065 }
41066 {
41067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41068 }
41069 return resultobj;
41070 fail:
41071 return NULL;
41072 }
41073
41074
41075 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41076 PyObject *resultobj = 0;
41077 wxWindow *arg1 = (wxWindow *) 0 ;
41078 byte arg2 ;
41079 bool result;
41080 void *argp1 = 0 ;
41081 int res1 = 0 ;
41082 unsigned char val2 ;
41083 int ecode2 = 0 ;
41084 PyObject * obj0 = 0 ;
41085 PyObject * obj1 = 0 ;
41086 char * kwnames[] = {
41087 (char *) "self",(char *) "alpha", NULL
41088 };
41089
41090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41092 if (!SWIG_IsOK(res1)) {
41093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41094 }
41095 arg1 = reinterpret_cast< wxWindow * >(argp1);
41096 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41097 if (!SWIG_IsOK(ecode2)) {
41098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41099 }
41100 arg2 = static_cast< byte >(val2);
41101 {
41102 PyThreadState* __tstate = wxPyBeginAllowThreads();
41103 result = (bool)(arg1)->SetTransparent(arg2);
41104 wxPyEndAllowThreads(__tstate);
41105 if (PyErr_Occurred()) SWIG_fail;
41106 }
41107 {
41108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41109 }
41110 return resultobj;
41111 fail:
41112 return NULL;
41113 }
41114
41115
41116 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41117 PyObject *obj;
41118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41119 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41120 return SWIG_Py_Void();
41121 }
41122
41123 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41124 return SWIG_Python_InitShadowInstance(args);
41125 }
41126
41127 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41128 PyObject *resultobj = 0;
41129 long arg1 ;
41130 wxWindow *arg2 = (wxWindow *) NULL ;
41131 wxWindow *result = 0 ;
41132 long val1 ;
41133 int ecode1 = 0 ;
41134 void *argp2 = 0 ;
41135 int res2 = 0 ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 char * kwnames[] = {
41139 (char *) "id",(char *) "parent", NULL
41140 };
41141
41142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41143 ecode1 = SWIG_AsVal_long(obj0, &val1);
41144 if (!SWIG_IsOK(ecode1)) {
41145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41146 }
41147 arg1 = static_cast< long >(val1);
41148 if (obj1) {
41149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41150 if (!SWIG_IsOK(res2)) {
41151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41152 }
41153 arg2 = reinterpret_cast< wxWindow * >(argp2);
41154 }
41155 {
41156 if (!wxPyCheckForApp()) SWIG_fail;
41157 PyThreadState* __tstate = wxPyBeginAllowThreads();
41158 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41159 wxPyEndAllowThreads(__tstate);
41160 if (PyErr_Occurred()) SWIG_fail;
41161 }
41162 {
41163 resultobj = wxPyMake_wxObject(result, 0);
41164 }
41165 return resultobj;
41166 fail:
41167 return NULL;
41168 }
41169
41170
41171 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41172 PyObject *resultobj = 0;
41173 wxString *arg1 = 0 ;
41174 wxWindow *arg2 = (wxWindow *) NULL ;
41175 wxWindow *result = 0 ;
41176 bool temp1 = false ;
41177 void *argp2 = 0 ;
41178 int res2 = 0 ;
41179 PyObject * obj0 = 0 ;
41180 PyObject * obj1 = 0 ;
41181 char * kwnames[] = {
41182 (char *) "name",(char *) "parent", NULL
41183 };
41184
41185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41186 {
41187 arg1 = wxString_in_helper(obj0);
41188 if (arg1 == NULL) SWIG_fail;
41189 temp1 = true;
41190 }
41191 if (obj1) {
41192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41193 if (!SWIG_IsOK(res2)) {
41194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41195 }
41196 arg2 = reinterpret_cast< wxWindow * >(argp2);
41197 }
41198 {
41199 if (!wxPyCheckForApp()) SWIG_fail;
41200 PyThreadState* __tstate = wxPyBeginAllowThreads();
41201 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41202 wxPyEndAllowThreads(__tstate);
41203 if (PyErr_Occurred()) SWIG_fail;
41204 }
41205 {
41206 resultobj = wxPyMake_wxObject(result, 0);
41207 }
41208 {
41209 if (temp1)
41210 delete arg1;
41211 }
41212 return resultobj;
41213 fail:
41214 {
41215 if (temp1)
41216 delete arg1;
41217 }
41218 return NULL;
41219 }
41220
41221
41222 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41223 PyObject *resultobj = 0;
41224 wxString *arg1 = 0 ;
41225 wxWindow *arg2 = (wxWindow *) NULL ;
41226 wxWindow *result = 0 ;
41227 bool temp1 = false ;
41228 void *argp2 = 0 ;
41229 int res2 = 0 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char * kwnames[] = {
41233 (char *) "label",(char *) "parent", NULL
41234 };
41235
41236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41237 {
41238 arg1 = wxString_in_helper(obj0);
41239 if (arg1 == NULL) SWIG_fail;
41240 temp1 = true;
41241 }
41242 if (obj1) {
41243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41244 if (!SWIG_IsOK(res2)) {
41245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41246 }
41247 arg2 = reinterpret_cast< wxWindow * >(argp2);
41248 }
41249 {
41250 if (!wxPyCheckForApp()) SWIG_fail;
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41253 wxPyEndAllowThreads(__tstate);
41254 if (PyErr_Occurred()) SWIG_fail;
41255 }
41256 {
41257 resultobj = wxPyMake_wxObject(result, 0);
41258 }
41259 {
41260 if (temp1)
41261 delete arg1;
41262 }
41263 return resultobj;
41264 fail:
41265 {
41266 if (temp1)
41267 delete arg1;
41268 }
41269 return NULL;
41270 }
41271
41272
41273 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41274 PyObject *resultobj = 0;
41275 wxWindow *arg1 = (wxWindow *) 0 ;
41276 unsigned long arg2 ;
41277 wxWindow *result = 0 ;
41278 void *argp1 = 0 ;
41279 int res1 = 0 ;
41280 unsigned long val2 ;
41281 int ecode2 = 0 ;
41282 PyObject * obj0 = 0 ;
41283 PyObject * obj1 = 0 ;
41284 char * kwnames[] = {
41285 (char *) "parent",(char *) "_hWnd", NULL
41286 };
41287
41288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41290 if (!SWIG_IsOK(res1)) {
41291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41292 }
41293 arg1 = reinterpret_cast< wxWindow * >(argp1);
41294 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41295 if (!SWIG_IsOK(ecode2)) {
41296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41297 }
41298 arg2 = static_cast< unsigned long >(val2);
41299 {
41300 PyThreadState* __tstate = wxPyBeginAllowThreads();
41301 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41302 wxPyEndAllowThreads(__tstate);
41303 if (PyErr_Occurred()) SWIG_fail;
41304 }
41305 {
41306 resultobj = wxPyMake_wxObject(result, 0);
41307 }
41308 return resultobj;
41309 fail:
41310 return NULL;
41311 }
41312
41313
41314 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41315 PyObject *resultobj = 0;
41316 PyObject *result = 0 ;
41317
41318 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41319 {
41320 PyThreadState* __tstate = wxPyBeginAllowThreads();
41321 result = (PyObject *)GetTopLevelWindows();
41322 wxPyEndAllowThreads(__tstate);
41323 if (PyErr_Occurred()) SWIG_fail;
41324 }
41325 resultobj = result;
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41333 PyObject *resultobj = 0;
41334 wxValidator *result = 0 ;
41335
41336 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41337 {
41338 PyThreadState* __tstate = wxPyBeginAllowThreads();
41339 result = (wxValidator *)new wxValidator();
41340 wxPyEndAllowThreads(__tstate);
41341 if (PyErr_Occurred()) SWIG_fail;
41342 }
41343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41344 return resultobj;
41345 fail:
41346 return NULL;
41347 }
41348
41349
41350 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41351 PyObject *resultobj = 0;
41352 wxValidator *arg1 = (wxValidator *) 0 ;
41353 wxValidator *result = 0 ;
41354 void *argp1 = 0 ;
41355 int res1 = 0 ;
41356 PyObject *swig_obj[1] ;
41357
41358 if (!args) SWIG_fail;
41359 swig_obj[0] = args;
41360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41361 if (!SWIG_IsOK(res1)) {
41362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41363 }
41364 arg1 = reinterpret_cast< wxValidator * >(argp1);
41365 {
41366 PyThreadState* __tstate = wxPyBeginAllowThreads();
41367 result = (wxValidator *)(arg1)->Clone();
41368 wxPyEndAllowThreads(__tstate);
41369 if (PyErr_Occurred()) SWIG_fail;
41370 }
41371 {
41372 resultobj = wxPyMake_wxObject(result, 0);
41373 }
41374 return resultobj;
41375 fail:
41376 return NULL;
41377 }
41378
41379
41380 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41381 PyObject *resultobj = 0;
41382 wxValidator *arg1 = (wxValidator *) 0 ;
41383 wxWindow *arg2 = (wxWindow *) 0 ;
41384 bool result;
41385 void *argp1 = 0 ;
41386 int res1 = 0 ;
41387 void *argp2 = 0 ;
41388 int res2 = 0 ;
41389 PyObject * obj0 = 0 ;
41390 PyObject * obj1 = 0 ;
41391 char * kwnames[] = {
41392 (char *) "self",(char *) "parent", NULL
41393 };
41394
41395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41397 if (!SWIG_IsOK(res1)) {
41398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41399 }
41400 arg1 = reinterpret_cast< wxValidator * >(argp1);
41401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41402 if (!SWIG_IsOK(res2)) {
41403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41404 }
41405 arg2 = reinterpret_cast< wxWindow * >(argp2);
41406 {
41407 PyThreadState* __tstate = wxPyBeginAllowThreads();
41408 result = (bool)(arg1)->Validate(arg2);
41409 wxPyEndAllowThreads(__tstate);
41410 if (PyErr_Occurred()) SWIG_fail;
41411 }
41412 {
41413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41414 }
41415 return resultobj;
41416 fail:
41417 return NULL;
41418 }
41419
41420
41421 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41422 PyObject *resultobj = 0;
41423 wxValidator *arg1 = (wxValidator *) 0 ;
41424 bool result;
41425 void *argp1 = 0 ;
41426 int res1 = 0 ;
41427 PyObject *swig_obj[1] ;
41428
41429 if (!args) SWIG_fail;
41430 swig_obj[0] = args;
41431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41432 if (!SWIG_IsOK(res1)) {
41433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41434 }
41435 arg1 = reinterpret_cast< wxValidator * >(argp1);
41436 {
41437 PyThreadState* __tstate = wxPyBeginAllowThreads();
41438 result = (bool)(arg1)->TransferToWindow();
41439 wxPyEndAllowThreads(__tstate);
41440 if (PyErr_Occurred()) SWIG_fail;
41441 }
41442 {
41443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41444 }
41445 return resultobj;
41446 fail:
41447 return NULL;
41448 }
41449
41450
41451 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41452 PyObject *resultobj = 0;
41453 wxValidator *arg1 = (wxValidator *) 0 ;
41454 bool result;
41455 void *argp1 = 0 ;
41456 int res1 = 0 ;
41457 PyObject *swig_obj[1] ;
41458
41459 if (!args) SWIG_fail;
41460 swig_obj[0] = args;
41461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41462 if (!SWIG_IsOK(res1)) {
41463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41464 }
41465 arg1 = reinterpret_cast< wxValidator * >(argp1);
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (bool)(arg1)->TransferFromWindow();
41469 wxPyEndAllowThreads(__tstate);
41470 if (PyErr_Occurred()) SWIG_fail;
41471 }
41472 {
41473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41474 }
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41482 PyObject *resultobj = 0;
41483 wxValidator *arg1 = (wxValidator *) 0 ;
41484 wxWindow *result = 0 ;
41485 void *argp1 = 0 ;
41486 int res1 = 0 ;
41487 PyObject *swig_obj[1] ;
41488
41489 if (!args) SWIG_fail;
41490 swig_obj[0] = args;
41491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41492 if (!SWIG_IsOK(res1)) {
41493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41494 }
41495 arg1 = reinterpret_cast< wxValidator * >(argp1);
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (wxWindow *)(arg1)->GetWindow();
41499 wxPyEndAllowThreads(__tstate);
41500 if (PyErr_Occurred()) SWIG_fail;
41501 }
41502 {
41503 resultobj = wxPyMake_wxObject(result, 0);
41504 }
41505 return resultobj;
41506 fail:
41507 return NULL;
41508 }
41509
41510
41511 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41512 PyObject *resultobj = 0;
41513 wxValidator *arg1 = (wxValidator *) 0 ;
41514 wxWindow *arg2 = (wxWindow *) 0 ;
41515 void *argp1 = 0 ;
41516 int res1 = 0 ;
41517 void *argp2 = 0 ;
41518 int res2 = 0 ;
41519 PyObject * obj0 = 0 ;
41520 PyObject * obj1 = 0 ;
41521 char * kwnames[] = {
41522 (char *) "self",(char *) "window", NULL
41523 };
41524
41525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41527 if (!SWIG_IsOK(res1)) {
41528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41529 }
41530 arg1 = reinterpret_cast< wxValidator * >(argp1);
41531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41532 if (!SWIG_IsOK(res2)) {
41533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41534 }
41535 arg2 = reinterpret_cast< wxWindow * >(argp2);
41536 {
41537 PyThreadState* __tstate = wxPyBeginAllowThreads();
41538 (arg1)->SetWindow(arg2);
41539 wxPyEndAllowThreads(__tstate);
41540 if (PyErr_Occurred()) SWIG_fail;
41541 }
41542 resultobj = SWIG_Py_Void();
41543 return resultobj;
41544 fail:
41545 return NULL;
41546 }
41547
41548
41549 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41550 PyObject *resultobj = 0;
41551 bool result;
41552
41553 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41554 {
41555 PyThreadState* __tstate = wxPyBeginAllowThreads();
41556 result = (bool)wxValidator::IsSilent();
41557 wxPyEndAllowThreads(__tstate);
41558 if (PyErr_Occurred()) SWIG_fail;
41559 }
41560 {
41561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41562 }
41563 return resultobj;
41564 fail:
41565 return NULL;
41566 }
41567
41568
41569 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41570 PyObject *resultobj = 0;
41571 int arg1 = (int) true ;
41572 int val1 ;
41573 int ecode1 = 0 ;
41574 PyObject * obj0 = 0 ;
41575 char * kwnames[] = {
41576 (char *) "doIt", NULL
41577 };
41578
41579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41580 if (obj0) {
41581 ecode1 = SWIG_AsVal_int(obj0, &val1);
41582 if (!SWIG_IsOK(ecode1)) {
41583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41584 }
41585 arg1 = static_cast< int >(val1);
41586 }
41587 {
41588 PyThreadState* __tstate = wxPyBeginAllowThreads();
41589 wxValidator::SetBellOnError(arg1);
41590 wxPyEndAllowThreads(__tstate);
41591 if (PyErr_Occurred()) SWIG_fail;
41592 }
41593 resultobj = SWIG_Py_Void();
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41601 PyObject *obj;
41602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41603 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41604 return SWIG_Py_Void();
41605 }
41606
41607 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41608 return SWIG_Python_InitShadowInstance(args);
41609 }
41610
41611 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41612 PyObject *resultobj = 0;
41613 wxPyValidator *result = 0 ;
41614
41615 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 result = (wxPyValidator *)new wxPyValidator();
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41623 return resultobj;
41624 fail:
41625 return NULL;
41626 }
41627
41628
41629 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41630 PyObject *resultobj = 0;
41631 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41632 PyObject *arg2 = (PyObject *) 0 ;
41633 PyObject *arg3 = (PyObject *) 0 ;
41634 int arg4 = (int) 1 ;
41635 void *argp1 = 0 ;
41636 int res1 = 0 ;
41637 int val4 ;
41638 int ecode4 = 0 ;
41639 PyObject * obj0 = 0 ;
41640 PyObject * obj1 = 0 ;
41641 PyObject * obj2 = 0 ;
41642 PyObject * obj3 = 0 ;
41643 char * kwnames[] = {
41644 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41645 };
41646
41647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41649 if (!SWIG_IsOK(res1)) {
41650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41651 }
41652 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41653 arg2 = obj1;
41654 arg3 = obj2;
41655 if (obj3) {
41656 ecode4 = SWIG_AsVal_int(obj3, &val4);
41657 if (!SWIG_IsOK(ecode4)) {
41658 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41659 }
41660 arg4 = static_cast< int >(val4);
41661 }
41662 {
41663 PyThreadState* __tstate = wxPyBeginAllowThreads();
41664 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41665 wxPyEndAllowThreads(__tstate);
41666 if (PyErr_Occurred()) SWIG_fail;
41667 }
41668 resultobj = SWIG_Py_Void();
41669 return resultobj;
41670 fail:
41671 return NULL;
41672 }
41673
41674
41675 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41676 PyObject *obj;
41677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41678 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41679 return SWIG_Py_Void();
41680 }
41681
41682 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41683 return SWIG_Python_InitShadowInstance(args);
41684 }
41685
41686 SWIGINTERN int DefaultValidator_set(PyObject *) {
41687 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41688 return 1;
41689 }
41690
41691
41692 SWIGINTERN PyObject *DefaultValidator_get(void) {
41693 PyObject *pyobj = 0;
41694
41695 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41696 return pyobj;
41697 }
41698
41699
41700 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj = 0;
41702 wxString const &arg1_defvalue = wxPyEmptyString ;
41703 wxString *arg1 = (wxString *) &arg1_defvalue ;
41704 long arg2 = (long) 0 ;
41705 wxMenu *result = 0 ;
41706 bool temp1 = false ;
41707 long val2 ;
41708 int ecode2 = 0 ;
41709 PyObject * obj0 = 0 ;
41710 PyObject * obj1 = 0 ;
41711 char * kwnames[] = {
41712 (char *) "title",(char *) "style", NULL
41713 };
41714
41715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41716 if (obj0) {
41717 {
41718 arg1 = wxString_in_helper(obj0);
41719 if (arg1 == NULL) SWIG_fail;
41720 temp1 = true;
41721 }
41722 }
41723 if (obj1) {
41724 ecode2 = SWIG_AsVal_long(obj1, &val2);
41725 if (!SWIG_IsOK(ecode2)) {
41726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41727 }
41728 arg2 = static_cast< long >(val2);
41729 }
41730 {
41731 if (!wxPyCheckForApp()) SWIG_fail;
41732 PyThreadState* __tstate = wxPyBeginAllowThreads();
41733 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41738 {
41739 if (temp1)
41740 delete arg1;
41741 }
41742 return resultobj;
41743 fail:
41744 {
41745 if (temp1)
41746 delete arg1;
41747 }
41748 return NULL;
41749 }
41750
41751
41752 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj = 0;
41754 wxMenu *arg1 = (wxMenu *) 0 ;
41755 int arg2 ;
41756 wxString const &arg3_defvalue = wxPyEmptyString ;
41757 wxString *arg3 = (wxString *) &arg3_defvalue ;
41758 wxString const &arg4_defvalue = wxPyEmptyString ;
41759 wxString *arg4 = (wxString *) &arg4_defvalue ;
41760 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41761 wxMenuItem *result = 0 ;
41762 void *argp1 = 0 ;
41763 int res1 = 0 ;
41764 int val2 ;
41765 int ecode2 = 0 ;
41766 bool temp3 = false ;
41767 bool temp4 = false ;
41768 int val5 ;
41769 int ecode5 = 0 ;
41770 PyObject * obj0 = 0 ;
41771 PyObject * obj1 = 0 ;
41772 PyObject * obj2 = 0 ;
41773 PyObject * obj3 = 0 ;
41774 PyObject * obj4 = 0 ;
41775 char * kwnames[] = {
41776 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41777 };
41778
41779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41781 if (!SWIG_IsOK(res1)) {
41782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41783 }
41784 arg1 = reinterpret_cast< wxMenu * >(argp1);
41785 ecode2 = SWIG_AsVal_int(obj1, &val2);
41786 if (!SWIG_IsOK(ecode2)) {
41787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41788 }
41789 arg2 = static_cast< int >(val2);
41790 if (obj2) {
41791 {
41792 arg3 = wxString_in_helper(obj2);
41793 if (arg3 == NULL) SWIG_fail;
41794 temp3 = true;
41795 }
41796 }
41797 if (obj3) {
41798 {
41799 arg4 = wxString_in_helper(obj3);
41800 if (arg4 == NULL) SWIG_fail;
41801 temp4 = true;
41802 }
41803 }
41804 if (obj4) {
41805 ecode5 = SWIG_AsVal_int(obj4, &val5);
41806 if (!SWIG_IsOK(ecode5)) {
41807 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41808 }
41809 arg5 = static_cast< wxItemKind >(val5);
41810 }
41811 {
41812 PyThreadState* __tstate = wxPyBeginAllowThreads();
41813 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41814 wxPyEndAllowThreads(__tstate);
41815 if (PyErr_Occurred()) SWIG_fail;
41816 }
41817 {
41818 resultobj = wxPyMake_wxObject(result, (bool)0);
41819 }
41820 {
41821 if (temp3)
41822 delete arg3;
41823 }
41824 {
41825 if (temp4)
41826 delete arg4;
41827 }
41828 return resultobj;
41829 fail:
41830 {
41831 if (temp3)
41832 delete arg3;
41833 }
41834 {
41835 if (temp4)
41836 delete arg4;
41837 }
41838 return NULL;
41839 }
41840
41841
41842 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41843 PyObject *resultobj = 0;
41844 wxMenu *arg1 = (wxMenu *) 0 ;
41845 wxMenuItem *result = 0 ;
41846 void *argp1 = 0 ;
41847 int res1 = 0 ;
41848 PyObject *swig_obj[1] ;
41849
41850 if (!args) SWIG_fail;
41851 swig_obj[0] = args;
41852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41853 if (!SWIG_IsOK(res1)) {
41854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41855 }
41856 arg1 = reinterpret_cast< wxMenu * >(argp1);
41857 {
41858 PyThreadState* __tstate = wxPyBeginAllowThreads();
41859 result = (wxMenuItem *)(arg1)->AppendSeparator();
41860 wxPyEndAllowThreads(__tstate);
41861 if (PyErr_Occurred()) SWIG_fail;
41862 }
41863 {
41864 resultobj = wxPyMake_wxObject(result, (bool)0);
41865 }
41866 return resultobj;
41867 fail:
41868 return NULL;
41869 }
41870
41871
41872 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj = 0;
41874 wxMenu *arg1 = (wxMenu *) 0 ;
41875 int arg2 ;
41876 wxString *arg3 = 0 ;
41877 wxString const &arg4_defvalue = wxPyEmptyString ;
41878 wxString *arg4 = (wxString *) &arg4_defvalue ;
41879 wxMenuItem *result = 0 ;
41880 void *argp1 = 0 ;
41881 int res1 = 0 ;
41882 int val2 ;
41883 int ecode2 = 0 ;
41884 bool temp3 = false ;
41885 bool temp4 = false ;
41886 PyObject * obj0 = 0 ;
41887 PyObject * obj1 = 0 ;
41888 PyObject * obj2 = 0 ;
41889 PyObject * obj3 = 0 ;
41890 char * kwnames[] = {
41891 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41892 };
41893
41894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41896 if (!SWIG_IsOK(res1)) {
41897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41898 }
41899 arg1 = reinterpret_cast< wxMenu * >(argp1);
41900 ecode2 = SWIG_AsVal_int(obj1, &val2);
41901 if (!SWIG_IsOK(ecode2)) {
41902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41903 }
41904 arg2 = static_cast< int >(val2);
41905 {
41906 arg3 = wxString_in_helper(obj2);
41907 if (arg3 == NULL) SWIG_fail;
41908 temp3 = true;
41909 }
41910 if (obj3) {
41911 {
41912 arg4 = wxString_in_helper(obj3);
41913 if (arg4 == NULL) SWIG_fail;
41914 temp4 = true;
41915 }
41916 }
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 {
41924 resultobj = wxPyMake_wxObject(result, (bool)0);
41925 }
41926 {
41927 if (temp3)
41928 delete arg3;
41929 }
41930 {
41931 if (temp4)
41932 delete arg4;
41933 }
41934 return resultobj;
41935 fail:
41936 {
41937 if (temp3)
41938 delete arg3;
41939 }
41940 {
41941 if (temp4)
41942 delete arg4;
41943 }
41944 return NULL;
41945 }
41946
41947
41948 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41949 PyObject *resultobj = 0;
41950 wxMenu *arg1 = (wxMenu *) 0 ;
41951 int arg2 ;
41952 wxString *arg3 = 0 ;
41953 wxString const &arg4_defvalue = wxPyEmptyString ;
41954 wxString *arg4 = (wxString *) &arg4_defvalue ;
41955 wxMenuItem *result = 0 ;
41956 void *argp1 = 0 ;
41957 int res1 = 0 ;
41958 int val2 ;
41959 int ecode2 = 0 ;
41960 bool temp3 = false ;
41961 bool temp4 = false ;
41962 PyObject * obj0 = 0 ;
41963 PyObject * obj1 = 0 ;
41964 PyObject * obj2 = 0 ;
41965 PyObject * obj3 = 0 ;
41966 char * kwnames[] = {
41967 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41968 };
41969
41970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41972 if (!SWIG_IsOK(res1)) {
41973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41974 }
41975 arg1 = reinterpret_cast< wxMenu * >(argp1);
41976 ecode2 = SWIG_AsVal_int(obj1, &val2);
41977 if (!SWIG_IsOK(ecode2)) {
41978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41979 }
41980 arg2 = static_cast< int >(val2);
41981 {
41982 arg3 = wxString_in_helper(obj2);
41983 if (arg3 == NULL) SWIG_fail;
41984 temp3 = true;
41985 }
41986 if (obj3) {
41987 {
41988 arg4 = wxString_in_helper(obj3);
41989 if (arg4 == NULL) SWIG_fail;
41990 temp4 = true;
41991 }
41992 }
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 {
42000 resultobj = wxPyMake_wxObject(result, (bool)0);
42001 }
42002 {
42003 if (temp3)
42004 delete arg3;
42005 }
42006 {
42007 if (temp4)
42008 delete arg4;
42009 }
42010 return resultobj;
42011 fail:
42012 {
42013 if (temp3)
42014 delete arg3;
42015 }
42016 {
42017 if (temp4)
42018 delete arg4;
42019 }
42020 return NULL;
42021 }
42022
42023
42024 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42025 PyObject *resultobj = 0;
42026 wxMenu *arg1 = (wxMenu *) 0 ;
42027 int arg2 ;
42028 wxString *arg3 = 0 ;
42029 wxMenu *arg4 = (wxMenu *) 0 ;
42030 wxString const &arg5_defvalue = wxPyEmptyString ;
42031 wxString *arg5 = (wxString *) &arg5_defvalue ;
42032 wxMenuItem *result = 0 ;
42033 void *argp1 = 0 ;
42034 int res1 = 0 ;
42035 int val2 ;
42036 int ecode2 = 0 ;
42037 bool temp3 = false ;
42038 void *argp4 = 0 ;
42039 int res4 = 0 ;
42040 bool temp5 = false ;
42041 PyObject * obj0 = 0 ;
42042 PyObject * obj1 = 0 ;
42043 PyObject * obj2 = 0 ;
42044 PyObject * obj3 = 0 ;
42045 PyObject * obj4 = 0 ;
42046 char * kwnames[] = {
42047 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42048 };
42049
42050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42052 if (!SWIG_IsOK(res1)) {
42053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42054 }
42055 arg1 = reinterpret_cast< wxMenu * >(argp1);
42056 ecode2 = SWIG_AsVal_int(obj1, &val2);
42057 if (!SWIG_IsOK(ecode2)) {
42058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42059 }
42060 arg2 = static_cast< int >(val2);
42061 {
42062 arg3 = wxString_in_helper(obj2);
42063 if (arg3 == NULL) SWIG_fail;
42064 temp3 = true;
42065 }
42066 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42067 if (!SWIG_IsOK(res4)) {
42068 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42069 }
42070 arg4 = reinterpret_cast< wxMenu * >(argp4);
42071 if (obj4) {
42072 {
42073 arg5 = wxString_in_helper(obj4);
42074 if (arg5 == NULL) SWIG_fail;
42075 temp5 = true;
42076 }
42077 }
42078 {
42079 PyThreadState* __tstate = wxPyBeginAllowThreads();
42080 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42081 wxPyEndAllowThreads(__tstate);
42082 if (PyErr_Occurred()) SWIG_fail;
42083 }
42084 {
42085 resultobj = wxPyMake_wxObject(result, (bool)0);
42086 }
42087 {
42088 if (temp3)
42089 delete arg3;
42090 }
42091 {
42092 if (temp5)
42093 delete arg5;
42094 }
42095 return resultobj;
42096 fail:
42097 {
42098 if (temp3)
42099 delete arg3;
42100 }
42101 {
42102 if (temp5)
42103 delete arg5;
42104 }
42105 return NULL;
42106 }
42107
42108
42109 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42110 PyObject *resultobj = 0;
42111 wxMenu *arg1 = (wxMenu *) 0 ;
42112 wxMenu *arg2 = (wxMenu *) 0 ;
42113 wxString *arg3 = 0 ;
42114 wxString const &arg4_defvalue = wxPyEmptyString ;
42115 wxString *arg4 = (wxString *) &arg4_defvalue ;
42116 wxMenuItem *result = 0 ;
42117 void *argp1 = 0 ;
42118 int res1 = 0 ;
42119 void *argp2 = 0 ;
42120 int res2 = 0 ;
42121 bool temp3 = false ;
42122 bool temp4 = false ;
42123 PyObject * obj0 = 0 ;
42124 PyObject * obj1 = 0 ;
42125 PyObject * obj2 = 0 ;
42126 PyObject * obj3 = 0 ;
42127 char * kwnames[] = {
42128 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42129 };
42130
42131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42133 if (!SWIG_IsOK(res1)) {
42134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42135 }
42136 arg1 = reinterpret_cast< wxMenu * >(argp1);
42137 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42138 if (!SWIG_IsOK(res2)) {
42139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42140 }
42141 arg2 = reinterpret_cast< wxMenu * >(argp2);
42142 {
42143 arg3 = wxString_in_helper(obj2);
42144 if (arg3 == NULL) SWIG_fail;
42145 temp3 = true;
42146 }
42147 if (obj3) {
42148 {
42149 arg4 = wxString_in_helper(obj3);
42150 if (arg4 == NULL) SWIG_fail;
42151 temp4 = true;
42152 }
42153 }
42154 {
42155 PyThreadState* __tstate = wxPyBeginAllowThreads();
42156 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42157 wxPyEndAllowThreads(__tstate);
42158 if (PyErr_Occurred()) SWIG_fail;
42159 }
42160 {
42161 resultobj = wxPyMake_wxObject(result, (bool)0);
42162 }
42163 {
42164 if (temp3)
42165 delete arg3;
42166 }
42167 {
42168 if (temp4)
42169 delete arg4;
42170 }
42171 return resultobj;
42172 fail:
42173 {
42174 if (temp3)
42175 delete arg3;
42176 }
42177 {
42178 if (temp4)
42179 delete arg4;
42180 }
42181 return NULL;
42182 }
42183
42184
42185 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42186 PyObject *resultobj = 0;
42187 wxMenu *arg1 = (wxMenu *) 0 ;
42188 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42189 wxMenuItem *result = 0 ;
42190 void *argp1 = 0 ;
42191 int res1 = 0 ;
42192 int res2 = 0 ;
42193 PyObject * obj0 = 0 ;
42194 PyObject * obj1 = 0 ;
42195 char * kwnames[] = {
42196 (char *) "self",(char *) "item", NULL
42197 };
42198
42199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42201 if (!SWIG_IsOK(res1)) {
42202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42203 }
42204 arg1 = reinterpret_cast< wxMenu * >(argp1);
42205 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42206 if (!SWIG_IsOK(res2)) {
42207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42208 }
42209 {
42210 PyThreadState* __tstate = wxPyBeginAllowThreads();
42211 result = (wxMenuItem *)(arg1)->Append(arg2);
42212 wxPyEndAllowThreads(__tstate);
42213 if (PyErr_Occurred()) SWIG_fail;
42214 }
42215 {
42216 resultobj = wxPyMake_wxObject(result, (bool)0);
42217 }
42218 return resultobj;
42219 fail:
42220 return NULL;
42221 }
42222
42223
42224 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42225 PyObject *resultobj = 0;
42226 wxMenu *arg1 = (wxMenu *) 0 ;
42227 size_t arg2 ;
42228 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42229 wxMenuItem *result = 0 ;
42230 void *argp1 = 0 ;
42231 int res1 = 0 ;
42232 size_t val2 ;
42233 int ecode2 = 0 ;
42234 int res3 = 0 ;
42235 PyObject * obj0 = 0 ;
42236 PyObject * obj1 = 0 ;
42237 PyObject * obj2 = 0 ;
42238 char * kwnames[] = {
42239 (char *) "self",(char *) "pos",(char *) "item", NULL
42240 };
42241
42242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42244 if (!SWIG_IsOK(res1)) {
42245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42246 }
42247 arg1 = reinterpret_cast< wxMenu * >(argp1);
42248 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42249 if (!SWIG_IsOK(ecode2)) {
42250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42251 }
42252 arg2 = static_cast< size_t >(val2);
42253 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42254 if (!SWIG_IsOK(res3)) {
42255 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42256 }
42257 {
42258 PyThreadState* __tstate = wxPyBeginAllowThreads();
42259 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 {
42264 resultobj = wxPyMake_wxObject(result, (bool)0);
42265 }
42266 return resultobj;
42267 fail:
42268 return NULL;
42269 }
42270
42271
42272 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42273 PyObject *resultobj = 0;
42274 wxMenu *arg1 = (wxMenu *) 0 ;
42275 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42276 wxMenuItem *result = 0 ;
42277 void *argp1 = 0 ;
42278 int res1 = 0 ;
42279 int res2 = 0 ;
42280 PyObject * obj0 = 0 ;
42281 PyObject * obj1 = 0 ;
42282 char * kwnames[] = {
42283 (char *) "self",(char *) "item", NULL
42284 };
42285
42286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42288 if (!SWIG_IsOK(res1)) {
42289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42290 }
42291 arg1 = reinterpret_cast< wxMenu * >(argp1);
42292 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42293 if (!SWIG_IsOK(res2)) {
42294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42295 }
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42299 wxPyEndAllowThreads(__tstate);
42300 if (PyErr_Occurred()) SWIG_fail;
42301 }
42302 {
42303 resultobj = wxPyMake_wxObject(result, (bool)0);
42304 }
42305 return resultobj;
42306 fail:
42307 return NULL;
42308 }
42309
42310
42311 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42312 PyObject *resultobj = 0;
42313 wxMenu *arg1 = (wxMenu *) 0 ;
42314 void *argp1 = 0 ;
42315 int res1 = 0 ;
42316 PyObject *swig_obj[1] ;
42317
42318 if (!args) SWIG_fail;
42319 swig_obj[0] = args;
42320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42321 if (!SWIG_IsOK(res1)) {
42322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42323 }
42324 arg1 = reinterpret_cast< wxMenu * >(argp1);
42325 {
42326 PyThreadState* __tstate = wxPyBeginAllowThreads();
42327 (arg1)->Break();
42328 wxPyEndAllowThreads(__tstate);
42329 if (PyErr_Occurred()) SWIG_fail;
42330 }
42331 resultobj = SWIG_Py_Void();
42332 return resultobj;
42333 fail:
42334 return NULL;
42335 }
42336
42337
42338 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42339 PyObject *resultobj = 0;
42340 wxMenu *arg1 = (wxMenu *) 0 ;
42341 size_t arg2 ;
42342 int arg3 ;
42343 wxString const &arg4_defvalue = wxPyEmptyString ;
42344 wxString *arg4 = (wxString *) &arg4_defvalue ;
42345 wxString const &arg5_defvalue = wxPyEmptyString ;
42346 wxString *arg5 = (wxString *) &arg5_defvalue ;
42347 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42348 wxMenuItem *result = 0 ;
42349 void *argp1 = 0 ;
42350 int res1 = 0 ;
42351 size_t val2 ;
42352 int ecode2 = 0 ;
42353 int val3 ;
42354 int ecode3 = 0 ;
42355 bool temp4 = false ;
42356 bool temp5 = false ;
42357 int val6 ;
42358 int ecode6 = 0 ;
42359 PyObject * obj0 = 0 ;
42360 PyObject * obj1 = 0 ;
42361 PyObject * obj2 = 0 ;
42362 PyObject * obj3 = 0 ;
42363 PyObject * obj4 = 0 ;
42364 PyObject * obj5 = 0 ;
42365 char * kwnames[] = {
42366 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42367 };
42368
42369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42371 if (!SWIG_IsOK(res1)) {
42372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42373 }
42374 arg1 = reinterpret_cast< wxMenu * >(argp1);
42375 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42376 if (!SWIG_IsOK(ecode2)) {
42377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42378 }
42379 arg2 = static_cast< size_t >(val2);
42380 ecode3 = SWIG_AsVal_int(obj2, &val3);
42381 if (!SWIG_IsOK(ecode3)) {
42382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42383 }
42384 arg3 = static_cast< int >(val3);
42385 if (obj3) {
42386 {
42387 arg4 = wxString_in_helper(obj3);
42388 if (arg4 == NULL) SWIG_fail;
42389 temp4 = true;
42390 }
42391 }
42392 if (obj4) {
42393 {
42394 arg5 = wxString_in_helper(obj4);
42395 if (arg5 == NULL) SWIG_fail;
42396 temp5 = true;
42397 }
42398 }
42399 if (obj5) {
42400 ecode6 = SWIG_AsVal_int(obj5, &val6);
42401 if (!SWIG_IsOK(ecode6)) {
42402 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42403 }
42404 arg6 = static_cast< wxItemKind >(val6);
42405 }
42406 {
42407 PyThreadState* __tstate = wxPyBeginAllowThreads();
42408 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42409 wxPyEndAllowThreads(__tstate);
42410 if (PyErr_Occurred()) SWIG_fail;
42411 }
42412 {
42413 resultobj = wxPyMake_wxObject(result, (bool)0);
42414 }
42415 {
42416 if (temp4)
42417 delete arg4;
42418 }
42419 {
42420 if (temp5)
42421 delete arg5;
42422 }
42423 return resultobj;
42424 fail:
42425 {
42426 if (temp4)
42427 delete arg4;
42428 }
42429 {
42430 if (temp5)
42431 delete arg5;
42432 }
42433 return NULL;
42434 }
42435
42436
42437 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42438 PyObject *resultobj = 0;
42439 wxMenu *arg1 = (wxMenu *) 0 ;
42440 size_t arg2 ;
42441 wxMenuItem *result = 0 ;
42442 void *argp1 = 0 ;
42443 int res1 = 0 ;
42444 size_t val2 ;
42445 int ecode2 = 0 ;
42446 PyObject * obj0 = 0 ;
42447 PyObject * obj1 = 0 ;
42448 char * kwnames[] = {
42449 (char *) "self",(char *) "pos", NULL
42450 };
42451
42452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42454 if (!SWIG_IsOK(res1)) {
42455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42456 }
42457 arg1 = reinterpret_cast< wxMenu * >(argp1);
42458 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42459 if (!SWIG_IsOK(ecode2)) {
42460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42461 }
42462 arg2 = static_cast< size_t >(val2);
42463 {
42464 PyThreadState* __tstate = wxPyBeginAllowThreads();
42465 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42466 wxPyEndAllowThreads(__tstate);
42467 if (PyErr_Occurred()) SWIG_fail;
42468 }
42469 {
42470 resultobj = wxPyMake_wxObject(result, (bool)0);
42471 }
42472 return resultobj;
42473 fail:
42474 return NULL;
42475 }
42476
42477
42478 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42479 PyObject *resultobj = 0;
42480 wxMenu *arg1 = (wxMenu *) 0 ;
42481 size_t arg2 ;
42482 int arg3 ;
42483 wxString *arg4 = 0 ;
42484 wxString const &arg5_defvalue = wxPyEmptyString ;
42485 wxString *arg5 = (wxString *) &arg5_defvalue ;
42486 wxMenuItem *result = 0 ;
42487 void *argp1 = 0 ;
42488 int res1 = 0 ;
42489 size_t val2 ;
42490 int ecode2 = 0 ;
42491 int val3 ;
42492 int ecode3 = 0 ;
42493 bool temp4 = false ;
42494 bool temp5 = false ;
42495 PyObject * obj0 = 0 ;
42496 PyObject * obj1 = 0 ;
42497 PyObject * obj2 = 0 ;
42498 PyObject * obj3 = 0 ;
42499 PyObject * obj4 = 0 ;
42500 char * kwnames[] = {
42501 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42502 };
42503
42504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42506 if (!SWIG_IsOK(res1)) {
42507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42508 }
42509 arg1 = reinterpret_cast< wxMenu * >(argp1);
42510 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42511 if (!SWIG_IsOK(ecode2)) {
42512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42513 }
42514 arg2 = static_cast< size_t >(val2);
42515 ecode3 = SWIG_AsVal_int(obj2, &val3);
42516 if (!SWIG_IsOK(ecode3)) {
42517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42518 }
42519 arg3 = static_cast< int >(val3);
42520 {
42521 arg4 = wxString_in_helper(obj3);
42522 if (arg4 == NULL) SWIG_fail;
42523 temp4 = true;
42524 }
42525 if (obj4) {
42526 {
42527 arg5 = wxString_in_helper(obj4);
42528 if (arg5 == NULL) SWIG_fail;
42529 temp5 = true;
42530 }
42531 }
42532 {
42533 PyThreadState* __tstate = wxPyBeginAllowThreads();
42534 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42535 wxPyEndAllowThreads(__tstate);
42536 if (PyErr_Occurred()) SWIG_fail;
42537 }
42538 {
42539 resultobj = wxPyMake_wxObject(result, (bool)0);
42540 }
42541 {
42542 if (temp4)
42543 delete arg4;
42544 }
42545 {
42546 if (temp5)
42547 delete arg5;
42548 }
42549 return resultobj;
42550 fail:
42551 {
42552 if (temp4)
42553 delete arg4;
42554 }
42555 {
42556 if (temp5)
42557 delete arg5;
42558 }
42559 return NULL;
42560 }
42561
42562
42563 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42564 PyObject *resultobj = 0;
42565 wxMenu *arg1 = (wxMenu *) 0 ;
42566 size_t arg2 ;
42567 int arg3 ;
42568 wxString *arg4 = 0 ;
42569 wxString const &arg5_defvalue = wxPyEmptyString ;
42570 wxString *arg5 = (wxString *) &arg5_defvalue ;
42571 wxMenuItem *result = 0 ;
42572 void *argp1 = 0 ;
42573 int res1 = 0 ;
42574 size_t val2 ;
42575 int ecode2 = 0 ;
42576 int val3 ;
42577 int ecode3 = 0 ;
42578 bool temp4 = false ;
42579 bool temp5 = false ;
42580 PyObject * obj0 = 0 ;
42581 PyObject * obj1 = 0 ;
42582 PyObject * obj2 = 0 ;
42583 PyObject * obj3 = 0 ;
42584 PyObject * obj4 = 0 ;
42585 char * kwnames[] = {
42586 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42587 };
42588
42589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42591 if (!SWIG_IsOK(res1)) {
42592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42593 }
42594 arg1 = reinterpret_cast< wxMenu * >(argp1);
42595 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42596 if (!SWIG_IsOK(ecode2)) {
42597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42598 }
42599 arg2 = static_cast< size_t >(val2);
42600 ecode3 = SWIG_AsVal_int(obj2, &val3);
42601 if (!SWIG_IsOK(ecode3)) {
42602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42603 }
42604 arg3 = static_cast< int >(val3);
42605 {
42606 arg4 = wxString_in_helper(obj3);
42607 if (arg4 == NULL) SWIG_fail;
42608 temp4 = true;
42609 }
42610 if (obj4) {
42611 {
42612 arg5 = wxString_in_helper(obj4);
42613 if (arg5 == NULL) SWIG_fail;
42614 temp5 = true;
42615 }
42616 }
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42620 wxPyEndAllowThreads(__tstate);
42621 if (PyErr_Occurred()) SWIG_fail;
42622 }
42623 {
42624 resultobj = wxPyMake_wxObject(result, (bool)0);
42625 }
42626 {
42627 if (temp4)
42628 delete arg4;
42629 }
42630 {
42631 if (temp5)
42632 delete arg5;
42633 }
42634 return resultobj;
42635 fail:
42636 {
42637 if (temp4)
42638 delete arg4;
42639 }
42640 {
42641 if (temp5)
42642 delete arg5;
42643 }
42644 return NULL;
42645 }
42646
42647
42648 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42649 PyObject *resultobj = 0;
42650 wxMenu *arg1 = (wxMenu *) 0 ;
42651 size_t arg2 ;
42652 int arg3 ;
42653 wxString *arg4 = 0 ;
42654 wxMenu *arg5 = (wxMenu *) 0 ;
42655 wxString const &arg6_defvalue = wxPyEmptyString ;
42656 wxString *arg6 = (wxString *) &arg6_defvalue ;
42657 wxMenuItem *result = 0 ;
42658 void *argp1 = 0 ;
42659 int res1 = 0 ;
42660 size_t val2 ;
42661 int ecode2 = 0 ;
42662 int val3 ;
42663 int ecode3 = 0 ;
42664 bool temp4 = false ;
42665 void *argp5 = 0 ;
42666 int res5 = 0 ;
42667 bool temp6 = false ;
42668 PyObject * obj0 = 0 ;
42669 PyObject * obj1 = 0 ;
42670 PyObject * obj2 = 0 ;
42671 PyObject * obj3 = 0 ;
42672 PyObject * obj4 = 0 ;
42673 PyObject * obj5 = 0 ;
42674 char * kwnames[] = {
42675 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42676 };
42677
42678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42680 if (!SWIG_IsOK(res1)) {
42681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42682 }
42683 arg1 = reinterpret_cast< wxMenu * >(argp1);
42684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42685 if (!SWIG_IsOK(ecode2)) {
42686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42687 }
42688 arg2 = static_cast< size_t >(val2);
42689 ecode3 = SWIG_AsVal_int(obj2, &val3);
42690 if (!SWIG_IsOK(ecode3)) {
42691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42692 }
42693 arg3 = static_cast< int >(val3);
42694 {
42695 arg4 = wxString_in_helper(obj3);
42696 if (arg4 == NULL) SWIG_fail;
42697 temp4 = true;
42698 }
42699 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42700 if (!SWIG_IsOK(res5)) {
42701 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42702 }
42703 arg5 = reinterpret_cast< wxMenu * >(argp5);
42704 if (obj5) {
42705 {
42706 arg6 = wxString_in_helper(obj5);
42707 if (arg6 == NULL) SWIG_fail;
42708 temp6 = true;
42709 }
42710 }
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42714 wxPyEndAllowThreads(__tstate);
42715 if (PyErr_Occurred()) SWIG_fail;
42716 }
42717 {
42718 resultobj = wxPyMake_wxObject(result, (bool)0);
42719 }
42720 {
42721 if (temp4)
42722 delete arg4;
42723 }
42724 {
42725 if (temp6)
42726 delete arg6;
42727 }
42728 return resultobj;
42729 fail:
42730 {
42731 if (temp4)
42732 delete arg4;
42733 }
42734 {
42735 if (temp6)
42736 delete arg6;
42737 }
42738 return NULL;
42739 }
42740
42741
42742 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42743 PyObject *resultobj = 0;
42744 wxMenu *arg1 = (wxMenu *) 0 ;
42745 int arg2 ;
42746 wxString const &arg3_defvalue = wxPyEmptyString ;
42747 wxString *arg3 = (wxString *) &arg3_defvalue ;
42748 wxString const &arg4_defvalue = wxPyEmptyString ;
42749 wxString *arg4 = (wxString *) &arg4_defvalue ;
42750 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42751 wxMenuItem *result = 0 ;
42752 void *argp1 = 0 ;
42753 int res1 = 0 ;
42754 int val2 ;
42755 int ecode2 = 0 ;
42756 bool temp3 = false ;
42757 bool temp4 = false ;
42758 int val5 ;
42759 int ecode5 = 0 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 PyObject * obj2 = 0 ;
42763 PyObject * obj3 = 0 ;
42764 PyObject * obj4 = 0 ;
42765 char * kwnames[] = {
42766 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42767 };
42768
42769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42771 if (!SWIG_IsOK(res1)) {
42772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42773 }
42774 arg1 = reinterpret_cast< wxMenu * >(argp1);
42775 ecode2 = SWIG_AsVal_int(obj1, &val2);
42776 if (!SWIG_IsOK(ecode2)) {
42777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42778 }
42779 arg2 = static_cast< int >(val2);
42780 if (obj2) {
42781 {
42782 arg3 = wxString_in_helper(obj2);
42783 if (arg3 == NULL) SWIG_fail;
42784 temp3 = true;
42785 }
42786 }
42787 if (obj3) {
42788 {
42789 arg4 = wxString_in_helper(obj3);
42790 if (arg4 == NULL) SWIG_fail;
42791 temp4 = true;
42792 }
42793 }
42794 if (obj4) {
42795 ecode5 = SWIG_AsVal_int(obj4, &val5);
42796 if (!SWIG_IsOK(ecode5)) {
42797 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42798 }
42799 arg5 = static_cast< wxItemKind >(val5);
42800 }
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 {
42808 resultobj = wxPyMake_wxObject(result, (bool)0);
42809 }
42810 {
42811 if (temp3)
42812 delete arg3;
42813 }
42814 {
42815 if (temp4)
42816 delete arg4;
42817 }
42818 return resultobj;
42819 fail:
42820 {
42821 if (temp3)
42822 delete arg3;
42823 }
42824 {
42825 if (temp4)
42826 delete arg4;
42827 }
42828 return NULL;
42829 }
42830
42831
42832 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42833 PyObject *resultobj = 0;
42834 wxMenu *arg1 = (wxMenu *) 0 ;
42835 wxMenuItem *result = 0 ;
42836 void *argp1 = 0 ;
42837 int res1 = 0 ;
42838 PyObject *swig_obj[1] ;
42839
42840 if (!args) SWIG_fail;
42841 swig_obj[0] = args;
42842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42843 if (!SWIG_IsOK(res1)) {
42844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42845 }
42846 arg1 = reinterpret_cast< wxMenu * >(argp1);
42847 {
42848 PyThreadState* __tstate = wxPyBeginAllowThreads();
42849 result = (wxMenuItem *)(arg1)->PrependSeparator();
42850 wxPyEndAllowThreads(__tstate);
42851 if (PyErr_Occurred()) SWIG_fail;
42852 }
42853 {
42854 resultobj = wxPyMake_wxObject(result, (bool)0);
42855 }
42856 return resultobj;
42857 fail:
42858 return NULL;
42859 }
42860
42861
42862 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42863 PyObject *resultobj = 0;
42864 wxMenu *arg1 = (wxMenu *) 0 ;
42865 int arg2 ;
42866 wxString *arg3 = 0 ;
42867 wxString const &arg4_defvalue = wxPyEmptyString ;
42868 wxString *arg4 = (wxString *) &arg4_defvalue ;
42869 wxMenuItem *result = 0 ;
42870 void *argp1 = 0 ;
42871 int res1 = 0 ;
42872 int val2 ;
42873 int ecode2 = 0 ;
42874 bool temp3 = false ;
42875 bool temp4 = false ;
42876 PyObject * obj0 = 0 ;
42877 PyObject * obj1 = 0 ;
42878 PyObject * obj2 = 0 ;
42879 PyObject * obj3 = 0 ;
42880 char * kwnames[] = {
42881 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42882 };
42883
42884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42886 if (!SWIG_IsOK(res1)) {
42887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42888 }
42889 arg1 = reinterpret_cast< wxMenu * >(argp1);
42890 ecode2 = SWIG_AsVal_int(obj1, &val2);
42891 if (!SWIG_IsOK(ecode2)) {
42892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42893 }
42894 arg2 = static_cast< int >(val2);
42895 {
42896 arg3 = wxString_in_helper(obj2);
42897 if (arg3 == NULL) SWIG_fail;
42898 temp3 = true;
42899 }
42900 if (obj3) {
42901 {
42902 arg4 = wxString_in_helper(obj3);
42903 if (arg4 == NULL) SWIG_fail;
42904 temp4 = true;
42905 }
42906 }
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42910 wxPyEndAllowThreads(__tstate);
42911 if (PyErr_Occurred()) SWIG_fail;
42912 }
42913 {
42914 resultobj = wxPyMake_wxObject(result, (bool)0);
42915 }
42916 {
42917 if (temp3)
42918 delete arg3;
42919 }
42920 {
42921 if (temp4)
42922 delete arg4;
42923 }
42924 return resultobj;
42925 fail:
42926 {
42927 if (temp3)
42928 delete arg3;
42929 }
42930 {
42931 if (temp4)
42932 delete arg4;
42933 }
42934 return NULL;
42935 }
42936
42937
42938 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42939 PyObject *resultobj = 0;
42940 wxMenu *arg1 = (wxMenu *) 0 ;
42941 int arg2 ;
42942 wxString *arg3 = 0 ;
42943 wxString const &arg4_defvalue = wxPyEmptyString ;
42944 wxString *arg4 = (wxString *) &arg4_defvalue ;
42945 wxMenuItem *result = 0 ;
42946 void *argp1 = 0 ;
42947 int res1 = 0 ;
42948 int val2 ;
42949 int ecode2 = 0 ;
42950 bool temp3 = false ;
42951 bool temp4 = false ;
42952 PyObject * obj0 = 0 ;
42953 PyObject * obj1 = 0 ;
42954 PyObject * obj2 = 0 ;
42955 PyObject * obj3 = 0 ;
42956 char * kwnames[] = {
42957 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42958 };
42959
42960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenu * >(argp1);
42966 ecode2 = SWIG_AsVal_int(obj1, &val2);
42967 if (!SWIG_IsOK(ecode2)) {
42968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42969 }
42970 arg2 = static_cast< int >(val2);
42971 {
42972 arg3 = wxString_in_helper(obj2);
42973 if (arg3 == NULL) SWIG_fail;
42974 temp3 = true;
42975 }
42976 if (obj3) {
42977 {
42978 arg4 = wxString_in_helper(obj3);
42979 if (arg4 == NULL) SWIG_fail;
42980 temp4 = true;
42981 }
42982 }
42983 {
42984 PyThreadState* __tstate = wxPyBeginAllowThreads();
42985 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42986 wxPyEndAllowThreads(__tstate);
42987 if (PyErr_Occurred()) SWIG_fail;
42988 }
42989 {
42990 resultobj = wxPyMake_wxObject(result, (bool)0);
42991 }
42992 {
42993 if (temp3)
42994 delete arg3;
42995 }
42996 {
42997 if (temp4)
42998 delete arg4;
42999 }
43000 return resultobj;
43001 fail:
43002 {
43003 if (temp3)
43004 delete arg3;
43005 }
43006 {
43007 if (temp4)
43008 delete arg4;
43009 }
43010 return NULL;
43011 }
43012
43013
43014 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43015 PyObject *resultobj = 0;
43016 wxMenu *arg1 = (wxMenu *) 0 ;
43017 int arg2 ;
43018 wxString *arg3 = 0 ;
43019 wxMenu *arg4 = (wxMenu *) 0 ;
43020 wxString const &arg5_defvalue = wxPyEmptyString ;
43021 wxString *arg5 = (wxString *) &arg5_defvalue ;
43022 wxMenuItem *result = 0 ;
43023 void *argp1 = 0 ;
43024 int res1 = 0 ;
43025 int val2 ;
43026 int ecode2 = 0 ;
43027 bool temp3 = false ;
43028 void *argp4 = 0 ;
43029 int res4 = 0 ;
43030 bool temp5 = false ;
43031 PyObject * obj0 = 0 ;
43032 PyObject * obj1 = 0 ;
43033 PyObject * obj2 = 0 ;
43034 PyObject * obj3 = 0 ;
43035 PyObject * obj4 = 0 ;
43036 char * kwnames[] = {
43037 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43038 };
43039
43040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43042 if (!SWIG_IsOK(res1)) {
43043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43044 }
43045 arg1 = reinterpret_cast< wxMenu * >(argp1);
43046 ecode2 = SWIG_AsVal_int(obj1, &val2);
43047 if (!SWIG_IsOK(ecode2)) {
43048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43049 }
43050 arg2 = static_cast< int >(val2);
43051 {
43052 arg3 = wxString_in_helper(obj2);
43053 if (arg3 == NULL) SWIG_fail;
43054 temp3 = true;
43055 }
43056 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43057 if (!SWIG_IsOK(res4)) {
43058 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43059 }
43060 arg4 = reinterpret_cast< wxMenu * >(argp4);
43061 if (obj4) {
43062 {
43063 arg5 = wxString_in_helper(obj4);
43064 if (arg5 == NULL) SWIG_fail;
43065 temp5 = true;
43066 }
43067 }
43068 {
43069 PyThreadState* __tstate = wxPyBeginAllowThreads();
43070 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 {
43075 resultobj = wxPyMake_wxObject(result, (bool)0);
43076 }
43077 {
43078 if (temp3)
43079 delete arg3;
43080 }
43081 {
43082 if (temp5)
43083 delete arg5;
43084 }
43085 return resultobj;
43086 fail:
43087 {
43088 if (temp3)
43089 delete arg3;
43090 }
43091 {
43092 if (temp5)
43093 delete arg5;
43094 }
43095 return NULL;
43096 }
43097
43098
43099 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43100 PyObject *resultobj = 0;
43101 wxMenu *arg1 = (wxMenu *) 0 ;
43102 int arg2 ;
43103 wxMenuItem *result = 0 ;
43104 void *argp1 = 0 ;
43105 int res1 = 0 ;
43106 int val2 ;
43107 int ecode2 = 0 ;
43108 PyObject * obj0 = 0 ;
43109 PyObject * obj1 = 0 ;
43110 char * kwnames[] = {
43111 (char *) "self",(char *) "id", NULL
43112 };
43113
43114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43116 if (!SWIG_IsOK(res1)) {
43117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43118 }
43119 arg1 = reinterpret_cast< wxMenu * >(argp1);
43120 ecode2 = SWIG_AsVal_int(obj1, &val2);
43121 if (!SWIG_IsOK(ecode2)) {
43122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43123 }
43124 arg2 = static_cast< int >(val2);
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = (wxMenuItem *)(arg1)->Remove(arg2);
43128 wxPyEndAllowThreads(__tstate);
43129 if (PyErr_Occurred()) SWIG_fail;
43130 }
43131 {
43132 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43133 }
43134 return resultobj;
43135 fail:
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43141 PyObject *resultobj = 0;
43142 wxMenu *arg1 = (wxMenu *) 0 ;
43143 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43144 wxMenuItem *result = 0 ;
43145 void *argp1 = 0 ;
43146 int res1 = 0 ;
43147 void *argp2 = 0 ;
43148 int res2 = 0 ;
43149 PyObject * obj0 = 0 ;
43150 PyObject * obj1 = 0 ;
43151 char * kwnames[] = {
43152 (char *) "self",(char *) "item", NULL
43153 };
43154
43155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43157 if (!SWIG_IsOK(res1)) {
43158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43159 }
43160 arg1 = reinterpret_cast< wxMenu * >(argp1);
43161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43162 if (!SWIG_IsOK(res2)) {
43163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43164 }
43165 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 result = (wxMenuItem *)(arg1)->Remove(arg2);
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 {
43173 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43174 }
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43182 PyObject *resultobj = 0;
43183 wxMenu *arg1 = (wxMenu *) 0 ;
43184 int arg2 ;
43185 bool result;
43186 void *argp1 = 0 ;
43187 int res1 = 0 ;
43188 int val2 ;
43189 int ecode2 = 0 ;
43190 PyObject * obj0 = 0 ;
43191 PyObject * obj1 = 0 ;
43192 char * kwnames[] = {
43193 (char *) "self",(char *) "id", NULL
43194 };
43195
43196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43198 if (!SWIG_IsOK(res1)) {
43199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43200 }
43201 arg1 = reinterpret_cast< wxMenu * >(argp1);
43202 ecode2 = SWIG_AsVal_int(obj1, &val2);
43203 if (!SWIG_IsOK(ecode2)) {
43204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43205 }
43206 arg2 = static_cast< int >(val2);
43207 {
43208 PyThreadState* __tstate = wxPyBeginAllowThreads();
43209 result = (bool)(arg1)->Delete(arg2);
43210 wxPyEndAllowThreads(__tstate);
43211 if (PyErr_Occurred()) SWIG_fail;
43212 }
43213 {
43214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43215 }
43216 return resultobj;
43217 fail:
43218 return NULL;
43219 }
43220
43221
43222 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43223 PyObject *resultobj = 0;
43224 wxMenu *arg1 = (wxMenu *) 0 ;
43225 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43226 bool result;
43227 void *argp1 = 0 ;
43228 int res1 = 0 ;
43229 void *argp2 = 0 ;
43230 int res2 = 0 ;
43231 PyObject * obj0 = 0 ;
43232 PyObject * obj1 = 0 ;
43233 char * kwnames[] = {
43234 (char *) "self",(char *) "item", NULL
43235 };
43236
43237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43239 if (!SWIG_IsOK(res1)) {
43240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43241 }
43242 arg1 = reinterpret_cast< wxMenu * >(argp1);
43243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43244 if (!SWIG_IsOK(res2)) {
43245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43246 }
43247 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43248 {
43249 PyThreadState* __tstate = wxPyBeginAllowThreads();
43250 result = (bool)(arg1)->Delete(arg2);
43251 wxPyEndAllowThreads(__tstate);
43252 if (PyErr_Occurred()) SWIG_fail;
43253 }
43254 {
43255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43256 }
43257 return resultobj;
43258 fail:
43259 return NULL;
43260 }
43261
43262
43263 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43264 PyObject *resultobj = 0;
43265 wxMenu *arg1 = (wxMenu *) 0 ;
43266 void *argp1 = 0 ;
43267 int res1 = 0 ;
43268 PyObject *swig_obj[1] ;
43269
43270 if (!args) SWIG_fail;
43271 swig_obj[0] = args;
43272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43273 if (!SWIG_IsOK(res1)) {
43274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43275 }
43276 arg1 = reinterpret_cast< wxMenu * >(argp1);
43277 {
43278 PyThreadState* __tstate = wxPyBeginAllowThreads();
43279 wxMenu_Destroy(arg1);
43280 wxPyEndAllowThreads(__tstate);
43281 if (PyErr_Occurred()) SWIG_fail;
43282 }
43283 resultobj = SWIG_Py_Void();
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43291 PyObject *resultobj = 0;
43292 wxMenu *arg1 = (wxMenu *) 0 ;
43293 int arg2 ;
43294 bool result;
43295 void *argp1 = 0 ;
43296 int res1 = 0 ;
43297 int val2 ;
43298 int ecode2 = 0 ;
43299 PyObject * obj0 = 0 ;
43300 PyObject * obj1 = 0 ;
43301 char * kwnames[] = {
43302 (char *) "self",(char *) "id", NULL
43303 };
43304
43305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43307 if (!SWIG_IsOK(res1)) {
43308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43309 }
43310 arg1 = reinterpret_cast< wxMenu * >(argp1);
43311 ecode2 = SWIG_AsVal_int(obj1, &val2);
43312 if (!SWIG_IsOK(ecode2)) {
43313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43314 }
43315 arg2 = static_cast< int >(val2);
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (bool)(arg1)->Destroy(arg2);
43319 wxPyEndAllowThreads(__tstate);
43320 if (PyErr_Occurred()) SWIG_fail;
43321 }
43322 {
43323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43324 }
43325 return resultobj;
43326 fail:
43327 return NULL;
43328 }
43329
43330
43331 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43332 PyObject *resultobj = 0;
43333 wxMenu *arg1 = (wxMenu *) 0 ;
43334 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43335 bool result;
43336 void *argp1 = 0 ;
43337 int res1 = 0 ;
43338 void *argp2 = 0 ;
43339 int res2 = 0 ;
43340 PyObject * obj0 = 0 ;
43341 PyObject * obj1 = 0 ;
43342 char * kwnames[] = {
43343 (char *) "self",(char *) "item", NULL
43344 };
43345
43346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43348 if (!SWIG_IsOK(res1)) {
43349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43350 }
43351 arg1 = reinterpret_cast< wxMenu * >(argp1);
43352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43353 if (!SWIG_IsOK(res2)) {
43354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43355 }
43356 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43357 {
43358 PyThreadState* __tstate = wxPyBeginAllowThreads();
43359 result = (bool)(arg1)->Destroy(arg2);
43360 wxPyEndAllowThreads(__tstate);
43361 if (PyErr_Occurred()) SWIG_fail;
43362 }
43363 {
43364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43365 }
43366 return resultobj;
43367 fail:
43368 return NULL;
43369 }
43370
43371
43372 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43373 PyObject *resultobj = 0;
43374 wxMenu *arg1 = (wxMenu *) 0 ;
43375 size_t result;
43376 void *argp1 = 0 ;
43377 int res1 = 0 ;
43378 PyObject *swig_obj[1] ;
43379
43380 if (!args) SWIG_fail;
43381 swig_obj[0] = args;
43382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43383 if (!SWIG_IsOK(res1)) {
43384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43385 }
43386 arg1 = reinterpret_cast< wxMenu * >(argp1);
43387 {
43388 PyThreadState* __tstate = wxPyBeginAllowThreads();
43389 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43390 wxPyEndAllowThreads(__tstate);
43391 if (PyErr_Occurred()) SWIG_fail;
43392 }
43393 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43394 return resultobj;
43395 fail:
43396 return NULL;
43397 }
43398
43399
43400 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43401 PyObject *resultobj = 0;
43402 wxMenu *arg1 = (wxMenu *) 0 ;
43403 PyObject *result = 0 ;
43404 void *argp1 = 0 ;
43405 int res1 = 0 ;
43406 PyObject *swig_obj[1] ;
43407
43408 if (!args) SWIG_fail;
43409 swig_obj[0] = args;
43410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43411 if (!SWIG_IsOK(res1)) {
43412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43413 }
43414 arg1 = reinterpret_cast< wxMenu * >(argp1);
43415 {
43416 PyThreadState* __tstate = wxPyBeginAllowThreads();
43417 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43418 wxPyEndAllowThreads(__tstate);
43419 if (PyErr_Occurred()) SWIG_fail;
43420 }
43421 resultobj = result;
43422 return resultobj;
43423 fail:
43424 return NULL;
43425 }
43426
43427
43428 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43429 PyObject *resultobj = 0;
43430 wxMenu *arg1 = (wxMenu *) 0 ;
43431 wxString *arg2 = 0 ;
43432 int result;
43433 void *argp1 = 0 ;
43434 int res1 = 0 ;
43435 bool temp2 = false ;
43436 PyObject * obj0 = 0 ;
43437 PyObject * obj1 = 0 ;
43438 char * kwnames[] = {
43439 (char *) "self",(char *) "item", NULL
43440 };
43441
43442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43444 if (!SWIG_IsOK(res1)) {
43445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43446 }
43447 arg1 = reinterpret_cast< wxMenu * >(argp1);
43448 {
43449 arg2 = wxString_in_helper(obj1);
43450 if (arg2 == NULL) SWIG_fail;
43451 temp2 = true;
43452 }
43453 {
43454 PyThreadState* __tstate = wxPyBeginAllowThreads();
43455 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43456 wxPyEndAllowThreads(__tstate);
43457 if (PyErr_Occurred()) SWIG_fail;
43458 }
43459 resultobj = SWIG_From_int(static_cast< int >(result));
43460 {
43461 if (temp2)
43462 delete arg2;
43463 }
43464 return resultobj;
43465 fail:
43466 {
43467 if (temp2)
43468 delete arg2;
43469 }
43470 return NULL;
43471 }
43472
43473
43474 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43475 PyObject *resultobj = 0;
43476 wxMenu *arg1 = (wxMenu *) 0 ;
43477 int arg2 ;
43478 wxMenuItem *result = 0 ;
43479 void *argp1 = 0 ;
43480 int res1 = 0 ;
43481 int val2 ;
43482 int ecode2 = 0 ;
43483 PyObject * obj0 = 0 ;
43484 PyObject * obj1 = 0 ;
43485 char * kwnames[] = {
43486 (char *) "self",(char *) "id", NULL
43487 };
43488
43489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43491 if (!SWIG_IsOK(res1)) {
43492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43493 }
43494 arg1 = reinterpret_cast< wxMenu * >(argp1);
43495 ecode2 = SWIG_AsVal_int(obj1, &val2);
43496 if (!SWIG_IsOK(ecode2)) {
43497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43498 }
43499 arg2 = static_cast< int >(val2);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 {
43507 resultobj = wxPyMake_wxObject(result, (bool)0);
43508 }
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43516 PyObject *resultobj = 0;
43517 wxMenu *arg1 = (wxMenu *) 0 ;
43518 size_t arg2 ;
43519 wxMenuItem *result = 0 ;
43520 void *argp1 = 0 ;
43521 int res1 = 0 ;
43522 size_t val2 ;
43523 int ecode2 = 0 ;
43524 PyObject * obj0 = 0 ;
43525 PyObject * obj1 = 0 ;
43526 char * kwnames[] = {
43527 (char *) "self",(char *) "position", NULL
43528 };
43529
43530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43532 if (!SWIG_IsOK(res1)) {
43533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43534 }
43535 arg1 = reinterpret_cast< wxMenu * >(argp1);
43536 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43537 if (!SWIG_IsOK(ecode2)) {
43538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43539 }
43540 arg2 = static_cast< size_t >(val2);
43541 {
43542 PyThreadState* __tstate = wxPyBeginAllowThreads();
43543 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43544 wxPyEndAllowThreads(__tstate);
43545 if (PyErr_Occurred()) SWIG_fail;
43546 }
43547 {
43548 resultobj = wxPyMake_wxObject(result, (bool)0);
43549 }
43550 return resultobj;
43551 fail:
43552 return NULL;
43553 }
43554
43555
43556 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43557 PyObject *resultobj = 0;
43558 wxMenu *arg1 = (wxMenu *) 0 ;
43559 int arg2 ;
43560 bool arg3 ;
43561 void *argp1 = 0 ;
43562 int res1 = 0 ;
43563 int val2 ;
43564 int ecode2 = 0 ;
43565 bool val3 ;
43566 int ecode3 = 0 ;
43567 PyObject * obj0 = 0 ;
43568 PyObject * obj1 = 0 ;
43569 PyObject * obj2 = 0 ;
43570 char * kwnames[] = {
43571 (char *) "self",(char *) "id",(char *) "enable", NULL
43572 };
43573
43574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43576 if (!SWIG_IsOK(res1)) {
43577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43578 }
43579 arg1 = reinterpret_cast< wxMenu * >(argp1);
43580 ecode2 = SWIG_AsVal_int(obj1, &val2);
43581 if (!SWIG_IsOK(ecode2)) {
43582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43583 }
43584 arg2 = static_cast< int >(val2);
43585 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43586 if (!SWIG_IsOK(ecode3)) {
43587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43588 }
43589 arg3 = static_cast< bool >(val3);
43590 {
43591 PyThreadState* __tstate = wxPyBeginAllowThreads();
43592 (arg1)->Enable(arg2,arg3);
43593 wxPyEndAllowThreads(__tstate);
43594 if (PyErr_Occurred()) SWIG_fail;
43595 }
43596 resultobj = SWIG_Py_Void();
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj = 0;
43605 wxMenu *arg1 = (wxMenu *) 0 ;
43606 int arg2 ;
43607 bool result;
43608 void *argp1 = 0 ;
43609 int res1 = 0 ;
43610 int val2 ;
43611 int ecode2 = 0 ;
43612 PyObject * obj0 = 0 ;
43613 PyObject * obj1 = 0 ;
43614 char * kwnames[] = {
43615 (char *) "self",(char *) "id", NULL
43616 };
43617
43618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43620 if (!SWIG_IsOK(res1)) {
43621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43622 }
43623 arg1 = reinterpret_cast< wxMenu * >(argp1);
43624 ecode2 = SWIG_AsVal_int(obj1, &val2);
43625 if (!SWIG_IsOK(ecode2)) {
43626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43627 }
43628 arg2 = static_cast< int >(val2);
43629 {
43630 PyThreadState* __tstate = wxPyBeginAllowThreads();
43631 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 {
43636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43637 }
43638 return resultobj;
43639 fail:
43640 return NULL;
43641 }
43642
43643
43644 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43645 PyObject *resultobj = 0;
43646 wxMenu *arg1 = (wxMenu *) 0 ;
43647 int arg2 ;
43648 bool arg3 ;
43649 void *argp1 = 0 ;
43650 int res1 = 0 ;
43651 int val2 ;
43652 int ecode2 = 0 ;
43653 bool val3 ;
43654 int ecode3 = 0 ;
43655 PyObject * obj0 = 0 ;
43656 PyObject * obj1 = 0 ;
43657 PyObject * obj2 = 0 ;
43658 char * kwnames[] = {
43659 (char *) "self",(char *) "id",(char *) "check", NULL
43660 };
43661
43662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43664 if (!SWIG_IsOK(res1)) {
43665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43666 }
43667 arg1 = reinterpret_cast< wxMenu * >(argp1);
43668 ecode2 = SWIG_AsVal_int(obj1, &val2);
43669 if (!SWIG_IsOK(ecode2)) {
43670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43671 }
43672 arg2 = static_cast< int >(val2);
43673 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43674 if (!SWIG_IsOK(ecode3)) {
43675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43676 }
43677 arg3 = static_cast< bool >(val3);
43678 {
43679 PyThreadState* __tstate = wxPyBeginAllowThreads();
43680 (arg1)->Check(arg2,arg3);
43681 wxPyEndAllowThreads(__tstate);
43682 if (PyErr_Occurred()) SWIG_fail;
43683 }
43684 resultobj = SWIG_Py_Void();
43685 return resultobj;
43686 fail:
43687 return NULL;
43688 }
43689
43690
43691 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43692 PyObject *resultobj = 0;
43693 wxMenu *arg1 = (wxMenu *) 0 ;
43694 int arg2 ;
43695 bool result;
43696 void *argp1 = 0 ;
43697 int res1 = 0 ;
43698 int val2 ;
43699 int ecode2 = 0 ;
43700 PyObject * obj0 = 0 ;
43701 PyObject * obj1 = 0 ;
43702 char * kwnames[] = {
43703 (char *) "self",(char *) "id", NULL
43704 };
43705
43706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43708 if (!SWIG_IsOK(res1)) {
43709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43710 }
43711 arg1 = reinterpret_cast< wxMenu * >(argp1);
43712 ecode2 = SWIG_AsVal_int(obj1, &val2);
43713 if (!SWIG_IsOK(ecode2)) {
43714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43715 }
43716 arg2 = static_cast< int >(val2);
43717 {
43718 PyThreadState* __tstate = wxPyBeginAllowThreads();
43719 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 {
43724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43725 }
43726 return resultobj;
43727 fail:
43728 return NULL;
43729 }
43730
43731
43732 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43733 PyObject *resultobj = 0;
43734 wxMenu *arg1 = (wxMenu *) 0 ;
43735 int arg2 ;
43736 wxString *arg3 = 0 ;
43737 void *argp1 = 0 ;
43738 int res1 = 0 ;
43739 int val2 ;
43740 int ecode2 = 0 ;
43741 bool temp3 = false ;
43742 PyObject * obj0 = 0 ;
43743 PyObject * obj1 = 0 ;
43744 PyObject * obj2 = 0 ;
43745 char * kwnames[] = {
43746 (char *) "self",(char *) "id",(char *) "label", NULL
43747 };
43748
43749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43751 if (!SWIG_IsOK(res1)) {
43752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43753 }
43754 arg1 = reinterpret_cast< wxMenu * >(argp1);
43755 ecode2 = SWIG_AsVal_int(obj1, &val2);
43756 if (!SWIG_IsOK(ecode2)) {
43757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43758 }
43759 arg2 = static_cast< int >(val2);
43760 {
43761 arg3 = wxString_in_helper(obj2);
43762 if (arg3 == NULL) SWIG_fail;
43763 temp3 = true;
43764 }
43765 {
43766 PyThreadState* __tstate = wxPyBeginAllowThreads();
43767 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43768 wxPyEndAllowThreads(__tstate);
43769 if (PyErr_Occurred()) SWIG_fail;
43770 }
43771 resultobj = SWIG_Py_Void();
43772 {
43773 if (temp3)
43774 delete arg3;
43775 }
43776 return resultobj;
43777 fail:
43778 {
43779 if (temp3)
43780 delete arg3;
43781 }
43782 return NULL;
43783 }
43784
43785
43786 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43787 PyObject *resultobj = 0;
43788 wxMenu *arg1 = (wxMenu *) 0 ;
43789 int arg2 ;
43790 wxString result;
43791 void *argp1 = 0 ;
43792 int res1 = 0 ;
43793 int val2 ;
43794 int ecode2 = 0 ;
43795 PyObject * obj0 = 0 ;
43796 PyObject * obj1 = 0 ;
43797 char * kwnames[] = {
43798 (char *) "self",(char *) "id", NULL
43799 };
43800
43801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43803 if (!SWIG_IsOK(res1)) {
43804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43805 }
43806 arg1 = reinterpret_cast< wxMenu * >(argp1);
43807 ecode2 = SWIG_AsVal_int(obj1, &val2);
43808 if (!SWIG_IsOK(ecode2)) {
43809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43810 }
43811 arg2 = static_cast< int >(val2);
43812 {
43813 PyThreadState* __tstate = wxPyBeginAllowThreads();
43814 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43815 wxPyEndAllowThreads(__tstate);
43816 if (PyErr_Occurred()) SWIG_fail;
43817 }
43818 {
43819 #if wxUSE_UNICODE
43820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43821 #else
43822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43823 #endif
43824 }
43825 return resultobj;
43826 fail:
43827 return NULL;
43828 }
43829
43830
43831 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43832 PyObject *resultobj = 0;
43833 wxMenu *arg1 = (wxMenu *) 0 ;
43834 int arg2 ;
43835 wxString *arg3 = 0 ;
43836 void *argp1 = 0 ;
43837 int res1 = 0 ;
43838 int val2 ;
43839 int ecode2 = 0 ;
43840 bool temp3 = false ;
43841 PyObject * obj0 = 0 ;
43842 PyObject * obj1 = 0 ;
43843 PyObject * obj2 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "id",(char *) "helpString", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43852 }
43853 arg1 = reinterpret_cast< wxMenu * >(argp1);
43854 ecode2 = SWIG_AsVal_int(obj1, &val2);
43855 if (!SWIG_IsOK(ecode2)) {
43856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43857 }
43858 arg2 = static_cast< int >(val2);
43859 {
43860 arg3 = wxString_in_helper(obj2);
43861 if (arg3 == NULL) SWIG_fail;
43862 temp3 = true;
43863 }
43864 {
43865 PyThreadState* __tstate = wxPyBeginAllowThreads();
43866 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43867 wxPyEndAllowThreads(__tstate);
43868 if (PyErr_Occurred()) SWIG_fail;
43869 }
43870 resultobj = SWIG_Py_Void();
43871 {
43872 if (temp3)
43873 delete arg3;
43874 }
43875 return resultobj;
43876 fail:
43877 {
43878 if (temp3)
43879 delete arg3;
43880 }
43881 return NULL;
43882 }
43883
43884
43885 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43886 PyObject *resultobj = 0;
43887 wxMenu *arg1 = (wxMenu *) 0 ;
43888 int arg2 ;
43889 wxString result;
43890 void *argp1 = 0 ;
43891 int res1 = 0 ;
43892 int val2 ;
43893 int ecode2 = 0 ;
43894 PyObject * obj0 = 0 ;
43895 PyObject * obj1 = 0 ;
43896 char * kwnames[] = {
43897 (char *) "self",(char *) "id", NULL
43898 };
43899
43900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43902 if (!SWIG_IsOK(res1)) {
43903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43904 }
43905 arg1 = reinterpret_cast< wxMenu * >(argp1);
43906 ecode2 = SWIG_AsVal_int(obj1, &val2);
43907 if (!SWIG_IsOK(ecode2)) {
43908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43909 }
43910 arg2 = static_cast< int >(val2);
43911 {
43912 PyThreadState* __tstate = wxPyBeginAllowThreads();
43913 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 {
43918 #if wxUSE_UNICODE
43919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43920 #else
43921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43922 #endif
43923 }
43924 return resultobj;
43925 fail:
43926 return NULL;
43927 }
43928
43929
43930 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43931 PyObject *resultobj = 0;
43932 wxMenu *arg1 = (wxMenu *) 0 ;
43933 wxString *arg2 = 0 ;
43934 void *argp1 = 0 ;
43935 int res1 = 0 ;
43936 bool temp2 = false ;
43937 PyObject * obj0 = 0 ;
43938 PyObject * obj1 = 0 ;
43939 char * kwnames[] = {
43940 (char *) "self",(char *) "title", NULL
43941 };
43942
43943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43945 if (!SWIG_IsOK(res1)) {
43946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43947 }
43948 arg1 = reinterpret_cast< wxMenu * >(argp1);
43949 {
43950 arg2 = wxString_in_helper(obj1);
43951 if (arg2 == NULL) SWIG_fail;
43952 temp2 = true;
43953 }
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 (arg1)->SetTitle((wxString const &)*arg2);
43957 wxPyEndAllowThreads(__tstate);
43958 if (PyErr_Occurred()) SWIG_fail;
43959 }
43960 resultobj = SWIG_Py_Void();
43961 {
43962 if (temp2)
43963 delete arg2;
43964 }
43965 return resultobj;
43966 fail:
43967 {
43968 if (temp2)
43969 delete arg2;
43970 }
43971 return NULL;
43972 }
43973
43974
43975 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43976 PyObject *resultobj = 0;
43977 wxMenu *arg1 = (wxMenu *) 0 ;
43978 wxString result;
43979 void *argp1 = 0 ;
43980 int res1 = 0 ;
43981 PyObject *swig_obj[1] ;
43982
43983 if (!args) SWIG_fail;
43984 swig_obj[0] = args;
43985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43986 if (!SWIG_IsOK(res1)) {
43987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43988 }
43989 arg1 = reinterpret_cast< wxMenu * >(argp1);
43990 {
43991 PyThreadState* __tstate = wxPyBeginAllowThreads();
43992 result = ((wxMenu const *)arg1)->GetTitle();
43993 wxPyEndAllowThreads(__tstate);
43994 if (PyErr_Occurred()) SWIG_fail;
43995 }
43996 {
43997 #if wxUSE_UNICODE
43998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43999 #else
44000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44001 #endif
44002 }
44003 return resultobj;
44004 fail:
44005 return NULL;
44006 }
44007
44008
44009 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44010 PyObject *resultobj = 0;
44011 wxMenu *arg1 = (wxMenu *) 0 ;
44012 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44013 void *argp1 = 0 ;
44014 int res1 = 0 ;
44015 void *argp2 = 0 ;
44016 int res2 = 0 ;
44017 PyObject * obj0 = 0 ;
44018 PyObject * obj1 = 0 ;
44019 char * kwnames[] = {
44020 (char *) "self",(char *) "handler", NULL
44021 };
44022
44023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44025 if (!SWIG_IsOK(res1)) {
44026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44027 }
44028 arg1 = reinterpret_cast< wxMenu * >(argp1);
44029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44030 if (!SWIG_IsOK(res2)) {
44031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44032 }
44033 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44034 {
44035 PyThreadState* __tstate = wxPyBeginAllowThreads();
44036 (arg1)->SetEventHandler(arg2);
44037 wxPyEndAllowThreads(__tstate);
44038 if (PyErr_Occurred()) SWIG_fail;
44039 }
44040 resultobj = SWIG_Py_Void();
44041 return resultobj;
44042 fail:
44043 return NULL;
44044 }
44045
44046
44047 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44048 PyObject *resultobj = 0;
44049 wxMenu *arg1 = (wxMenu *) 0 ;
44050 wxEvtHandler *result = 0 ;
44051 void *argp1 = 0 ;
44052 int res1 = 0 ;
44053 PyObject *swig_obj[1] ;
44054
44055 if (!args) SWIG_fail;
44056 swig_obj[0] = args;
44057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44058 if (!SWIG_IsOK(res1)) {
44059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44060 }
44061 arg1 = reinterpret_cast< wxMenu * >(argp1);
44062 {
44063 PyThreadState* __tstate = wxPyBeginAllowThreads();
44064 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44065 wxPyEndAllowThreads(__tstate);
44066 if (PyErr_Occurred()) SWIG_fail;
44067 }
44068 {
44069 resultobj = wxPyMake_wxObject(result, 0);
44070 }
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj = 0;
44079 wxMenu *arg1 = (wxMenu *) 0 ;
44080 wxWindow *arg2 = (wxWindow *) 0 ;
44081 void *argp1 = 0 ;
44082 int res1 = 0 ;
44083 void *argp2 = 0 ;
44084 int res2 = 0 ;
44085 PyObject * obj0 = 0 ;
44086 PyObject * obj1 = 0 ;
44087 char * kwnames[] = {
44088 (char *) "self",(char *) "win", NULL
44089 };
44090
44091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44093 if (!SWIG_IsOK(res1)) {
44094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44095 }
44096 arg1 = reinterpret_cast< wxMenu * >(argp1);
44097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44098 if (!SWIG_IsOK(res2)) {
44099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44100 }
44101 arg2 = reinterpret_cast< wxWindow * >(argp2);
44102 {
44103 PyThreadState* __tstate = wxPyBeginAllowThreads();
44104 (arg1)->SetInvokingWindow(arg2);
44105 wxPyEndAllowThreads(__tstate);
44106 if (PyErr_Occurred()) SWIG_fail;
44107 }
44108 resultobj = SWIG_Py_Void();
44109 return resultobj;
44110 fail:
44111 return NULL;
44112 }
44113
44114
44115 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44116 PyObject *resultobj = 0;
44117 wxMenu *arg1 = (wxMenu *) 0 ;
44118 wxWindow *result = 0 ;
44119 void *argp1 = 0 ;
44120 int res1 = 0 ;
44121 PyObject *swig_obj[1] ;
44122
44123 if (!args) SWIG_fail;
44124 swig_obj[0] = args;
44125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44126 if (!SWIG_IsOK(res1)) {
44127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44128 }
44129 arg1 = reinterpret_cast< wxMenu * >(argp1);
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 {
44137 resultobj = wxPyMake_wxObject(result, 0);
44138 }
44139 return resultobj;
44140 fail:
44141 return NULL;
44142 }
44143
44144
44145 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44146 PyObject *resultobj = 0;
44147 wxMenu *arg1 = (wxMenu *) 0 ;
44148 long result;
44149 void *argp1 = 0 ;
44150 int res1 = 0 ;
44151 PyObject *swig_obj[1] ;
44152
44153 if (!args) SWIG_fail;
44154 swig_obj[0] = args;
44155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44156 if (!SWIG_IsOK(res1)) {
44157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44158 }
44159 arg1 = reinterpret_cast< wxMenu * >(argp1);
44160 {
44161 PyThreadState* __tstate = wxPyBeginAllowThreads();
44162 result = (long)((wxMenu const *)arg1)->GetStyle();
44163 wxPyEndAllowThreads(__tstate);
44164 if (PyErr_Occurred()) SWIG_fail;
44165 }
44166 resultobj = SWIG_From_long(static_cast< long >(result));
44167 return resultobj;
44168 fail:
44169 return NULL;
44170 }
44171
44172
44173 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44174 PyObject *resultobj = 0;
44175 wxMenu *arg1 = (wxMenu *) 0 ;
44176 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44177 void *argp1 = 0 ;
44178 int res1 = 0 ;
44179 void *argp2 = 0 ;
44180 int res2 = 0 ;
44181 PyObject * obj0 = 0 ;
44182 PyObject * obj1 = 0 ;
44183 char * kwnames[] = {
44184 (char *) "self",(char *) "source", NULL
44185 };
44186
44187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44189 if (!SWIG_IsOK(res1)) {
44190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44191 }
44192 arg1 = reinterpret_cast< wxMenu * >(argp1);
44193 if (obj1) {
44194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44195 if (!SWIG_IsOK(res2)) {
44196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44197 }
44198 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44199 }
44200 {
44201 PyThreadState* __tstate = wxPyBeginAllowThreads();
44202 (arg1)->UpdateUI(arg2);
44203 wxPyEndAllowThreads(__tstate);
44204 if (PyErr_Occurred()) SWIG_fail;
44205 }
44206 resultobj = SWIG_Py_Void();
44207 return resultobj;
44208 fail:
44209 return NULL;
44210 }
44211
44212
44213 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44214 PyObject *resultobj = 0;
44215 wxMenu *arg1 = (wxMenu *) 0 ;
44216 wxMenuBar *result = 0 ;
44217 void *argp1 = 0 ;
44218 int res1 = 0 ;
44219 PyObject *swig_obj[1] ;
44220
44221 if (!args) SWIG_fail;
44222 swig_obj[0] = args;
44223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44224 if (!SWIG_IsOK(res1)) {
44225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44226 }
44227 arg1 = reinterpret_cast< wxMenu * >(argp1);
44228 {
44229 PyThreadState* __tstate = wxPyBeginAllowThreads();
44230 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44231 wxPyEndAllowThreads(__tstate);
44232 if (PyErr_Occurred()) SWIG_fail;
44233 }
44234 {
44235 resultobj = wxPyMake_wxObject(result, (bool)0);
44236 }
44237 return resultobj;
44238 fail:
44239 return NULL;
44240 }
44241
44242
44243 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44244 PyObject *resultobj = 0;
44245 wxMenu *arg1 = (wxMenu *) 0 ;
44246 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44247 void *argp1 = 0 ;
44248 int res1 = 0 ;
44249 void *argp2 = 0 ;
44250 int res2 = 0 ;
44251 PyObject * obj0 = 0 ;
44252 PyObject * obj1 = 0 ;
44253 char * kwnames[] = {
44254 (char *) "self",(char *) "menubar", NULL
44255 };
44256
44257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44259 if (!SWIG_IsOK(res1)) {
44260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44261 }
44262 arg1 = reinterpret_cast< wxMenu * >(argp1);
44263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44264 if (!SWIG_IsOK(res2)) {
44265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44266 }
44267 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44268 {
44269 PyThreadState* __tstate = wxPyBeginAllowThreads();
44270 (arg1)->Attach(arg2);
44271 wxPyEndAllowThreads(__tstate);
44272 if (PyErr_Occurred()) SWIG_fail;
44273 }
44274 resultobj = SWIG_Py_Void();
44275 return resultobj;
44276 fail:
44277 return NULL;
44278 }
44279
44280
44281 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44282 PyObject *resultobj = 0;
44283 wxMenu *arg1 = (wxMenu *) 0 ;
44284 void *argp1 = 0 ;
44285 int res1 = 0 ;
44286 PyObject *swig_obj[1] ;
44287
44288 if (!args) SWIG_fail;
44289 swig_obj[0] = args;
44290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44291 if (!SWIG_IsOK(res1)) {
44292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44293 }
44294 arg1 = reinterpret_cast< wxMenu * >(argp1);
44295 {
44296 PyThreadState* __tstate = wxPyBeginAllowThreads();
44297 (arg1)->Detach();
44298 wxPyEndAllowThreads(__tstate);
44299 if (PyErr_Occurred()) SWIG_fail;
44300 }
44301 resultobj = SWIG_Py_Void();
44302 return resultobj;
44303 fail:
44304 return NULL;
44305 }
44306
44307
44308 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44309 PyObject *resultobj = 0;
44310 wxMenu *arg1 = (wxMenu *) 0 ;
44311 bool result;
44312 void *argp1 = 0 ;
44313 int res1 = 0 ;
44314 PyObject *swig_obj[1] ;
44315
44316 if (!args) SWIG_fail;
44317 swig_obj[0] = args;
44318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44319 if (!SWIG_IsOK(res1)) {
44320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44321 }
44322 arg1 = reinterpret_cast< wxMenu * >(argp1);
44323 {
44324 PyThreadState* __tstate = wxPyBeginAllowThreads();
44325 result = (bool)((wxMenu const *)arg1)->IsAttached();
44326 wxPyEndAllowThreads(__tstate);
44327 if (PyErr_Occurred()) SWIG_fail;
44328 }
44329 {
44330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44331 }
44332 return resultobj;
44333 fail:
44334 return NULL;
44335 }
44336
44337
44338 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44339 PyObject *resultobj = 0;
44340 wxMenu *arg1 = (wxMenu *) 0 ;
44341 wxMenu *arg2 = (wxMenu *) 0 ;
44342 void *argp1 = 0 ;
44343 int res1 = 0 ;
44344 void *argp2 = 0 ;
44345 int res2 = 0 ;
44346 PyObject * obj0 = 0 ;
44347 PyObject * obj1 = 0 ;
44348 char * kwnames[] = {
44349 (char *) "self",(char *) "parent", NULL
44350 };
44351
44352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44354 if (!SWIG_IsOK(res1)) {
44355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44356 }
44357 arg1 = reinterpret_cast< wxMenu * >(argp1);
44358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44359 if (!SWIG_IsOK(res2)) {
44360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44361 }
44362 arg2 = reinterpret_cast< wxMenu * >(argp2);
44363 {
44364 PyThreadState* __tstate = wxPyBeginAllowThreads();
44365 (arg1)->SetParent(arg2);
44366 wxPyEndAllowThreads(__tstate);
44367 if (PyErr_Occurred()) SWIG_fail;
44368 }
44369 resultobj = SWIG_Py_Void();
44370 return resultobj;
44371 fail:
44372 return NULL;
44373 }
44374
44375
44376 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44377 PyObject *resultobj = 0;
44378 wxMenu *arg1 = (wxMenu *) 0 ;
44379 wxMenu *result = 0 ;
44380 void *argp1 = 0 ;
44381 int res1 = 0 ;
44382 PyObject *swig_obj[1] ;
44383
44384 if (!args) SWIG_fail;
44385 swig_obj[0] = args;
44386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44387 if (!SWIG_IsOK(res1)) {
44388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44389 }
44390 arg1 = reinterpret_cast< wxMenu * >(argp1);
44391 {
44392 PyThreadState* __tstate = wxPyBeginAllowThreads();
44393 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44394 wxPyEndAllowThreads(__tstate);
44395 if (PyErr_Occurred()) SWIG_fail;
44396 }
44397 {
44398 resultobj = wxPyMake_wxObject(result, 0);
44399 }
44400 return resultobj;
44401 fail:
44402 return NULL;
44403 }
44404
44405
44406 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44407 PyObject *obj;
44408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44409 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44410 return SWIG_Py_Void();
44411 }
44412
44413 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44414 return SWIG_Python_InitShadowInstance(args);
44415 }
44416
44417 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44418 PyObject *resultobj = 0;
44419 long arg1 = (long) 0 ;
44420 wxMenuBar *result = 0 ;
44421 long val1 ;
44422 int ecode1 = 0 ;
44423 PyObject * obj0 = 0 ;
44424 char * kwnames[] = {
44425 (char *) "style", NULL
44426 };
44427
44428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44429 if (obj0) {
44430 ecode1 = SWIG_AsVal_long(obj0, &val1);
44431 if (!SWIG_IsOK(ecode1)) {
44432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44433 }
44434 arg1 = static_cast< long >(val1);
44435 }
44436 {
44437 if (!wxPyCheckForApp()) SWIG_fail;
44438 PyThreadState* __tstate = wxPyBeginAllowThreads();
44439 result = (wxMenuBar *)new wxMenuBar(arg1);
44440 wxPyEndAllowThreads(__tstate);
44441 if (PyErr_Occurred()) SWIG_fail;
44442 }
44443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44451 PyObject *resultobj = 0;
44452 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44453 wxMenu *arg2 = (wxMenu *) 0 ;
44454 wxString *arg3 = 0 ;
44455 bool result;
44456 void *argp1 = 0 ;
44457 int res1 = 0 ;
44458 void *argp2 = 0 ;
44459 int res2 = 0 ;
44460 bool temp3 = false ;
44461 PyObject * obj0 = 0 ;
44462 PyObject * obj1 = 0 ;
44463 PyObject * obj2 = 0 ;
44464 char * kwnames[] = {
44465 (char *) "self",(char *) "menu",(char *) "title", NULL
44466 };
44467
44468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44470 if (!SWIG_IsOK(res1)) {
44471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44472 }
44473 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44474 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44475 if (!SWIG_IsOK(res2)) {
44476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44477 }
44478 arg2 = reinterpret_cast< wxMenu * >(argp2);
44479 {
44480 arg3 = wxString_in_helper(obj2);
44481 if (arg3 == NULL) SWIG_fail;
44482 temp3 = true;
44483 }
44484 {
44485 PyThreadState* __tstate = wxPyBeginAllowThreads();
44486 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44487 wxPyEndAllowThreads(__tstate);
44488 if (PyErr_Occurred()) SWIG_fail;
44489 }
44490 {
44491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44492 }
44493 {
44494 if (temp3)
44495 delete arg3;
44496 }
44497 return resultobj;
44498 fail:
44499 {
44500 if (temp3)
44501 delete arg3;
44502 }
44503 return NULL;
44504 }
44505
44506
44507 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44508 PyObject *resultobj = 0;
44509 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44510 size_t arg2 ;
44511 wxMenu *arg3 = (wxMenu *) 0 ;
44512 wxString *arg4 = 0 ;
44513 bool result;
44514 void *argp1 = 0 ;
44515 int res1 = 0 ;
44516 size_t val2 ;
44517 int ecode2 = 0 ;
44518 void *argp3 = 0 ;
44519 int res3 = 0 ;
44520 bool temp4 = false ;
44521 PyObject * obj0 = 0 ;
44522 PyObject * obj1 = 0 ;
44523 PyObject * obj2 = 0 ;
44524 PyObject * obj3 = 0 ;
44525 char * kwnames[] = {
44526 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44527 };
44528
44529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44531 if (!SWIG_IsOK(res1)) {
44532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44533 }
44534 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44535 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44536 if (!SWIG_IsOK(ecode2)) {
44537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44538 }
44539 arg2 = static_cast< size_t >(val2);
44540 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44541 if (!SWIG_IsOK(res3)) {
44542 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44543 }
44544 arg3 = reinterpret_cast< wxMenu * >(argp3);
44545 {
44546 arg4 = wxString_in_helper(obj3);
44547 if (arg4 == NULL) SWIG_fail;
44548 temp4 = true;
44549 }
44550 {
44551 PyThreadState* __tstate = wxPyBeginAllowThreads();
44552 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44553 wxPyEndAllowThreads(__tstate);
44554 if (PyErr_Occurred()) SWIG_fail;
44555 }
44556 {
44557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44558 }
44559 {
44560 if (temp4)
44561 delete arg4;
44562 }
44563 return resultobj;
44564 fail:
44565 {
44566 if (temp4)
44567 delete arg4;
44568 }
44569 return NULL;
44570 }
44571
44572
44573 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44574 PyObject *resultobj = 0;
44575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44576 size_t result;
44577 void *argp1 = 0 ;
44578 int res1 = 0 ;
44579 PyObject *swig_obj[1] ;
44580
44581 if (!args) SWIG_fail;
44582 swig_obj[0] = args;
44583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44584 if (!SWIG_IsOK(res1)) {
44585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44586 }
44587 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44588 {
44589 PyThreadState* __tstate = wxPyBeginAllowThreads();
44590 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44591 wxPyEndAllowThreads(__tstate);
44592 if (PyErr_Occurred()) SWIG_fail;
44593 }
44594 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44595 return resultobj;
44596 fail:
44597 return NULL;
44598 }
44599
44600
44601 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44602 PyObject *resultobj = 0;
44603 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44604 size_t arg2 ;
44605 wxMenu *result = 0 ;
44606 void *argp1 = 0 ;
44607 int res1 = 0 ;
44608 size_t val2 ;
44609 int ecode2 = 0 ;
44610 PyObject * obj0 = 0 ;
44611 PyObject * obj1 = 0 ;
44612 char * kwnames[] = {
44613 (char *) "self",(char *) "pos", NULL
44614 };
44615
44616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44618 if (!SWIG_IsOK(res1)) {
44619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44620 }
44621 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44622 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44623 if (!SWIG_IsOK(ecode2)) {
44624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44625 }
44626 arg2 = static_cast< size_t >(val2);
44627 {
44628 PyThreadState* __tstate = wxPyBeginAllowThreads();
44629 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44630 wxPyEndAllowThreads(__tstate);
44631 if (PyErr_Occurred()) SWIG_fail;
44632 }
44633 {
44634 resultobj = wxPyMake_wxObject(result, 0);
44635 }
44636 return resultobj;
44637 fail:
44638 return NULL;
44639 }
44640
44641
44642 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj = 0;
44644 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44645 size_t arg2 ;
44646 wxMenu *arg3 = (wxMenu *) 0 ;
44647 wxString *arg4 = 0 ;
44648 wxMenu *result = 0 ;
44649 void *argp1 = 0 ;
44650 int res1 = 0 ;
44651 size_t val2 ;
44652 int ecode2 = 0 ;
44653 void *argp3 = 0 ;
44654 int res3 = 0 ;
44655 bool temp4 = false ;
44656 PyObject * obj0 = 0 ;
44657 PyObject * obj1 = 0 ;
44658 PyObject * obj2 = 0 ;
44659 PyObject * obj3 = 0 ;
44660 char * kwnames[] = {
44661 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44662 };
44663
44664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44666 if (!SWIG_IsOK(res1)) {
44667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44668 }
44669 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44670 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44671 if (!SWIG_IsOK(ecode2)) {
44672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44673 }
44674 arg2 = static_cast< size_t >(val2);
44675 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44676 if (!SWIG_IsOK(res3)) {
44677 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44678 }
44679 arg3 = reinterpret_cast< wxMenu * >(argp3);
44680 {
44681 arg4 = wxString_in_helper(obj3);
44682 if (arg4 == NULL) SWIG_fail;
44683 temp4 = true;
44684 }
44685 {
44686 PyThreadState* __tstate = wxPyBeginAllowThreads();
44687 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44688 wxPyEndAllowThreads(__tstate);
44689 if (PyErr_Occurred()) SWIG_fail;
44690 }
44691 {
44692 resultobj = wxPyMake_wxObject(result, 0);
44693 }
44694 {
44695 if (temp4)
44696 delete arg4;
44697 }
44698 return resultobj;
44699 fail:
44700 {
44701 if (temp4)
44702 delete arg4;
44703 }
44704 return NULL;
44705 }
44706
44707
44708 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44709 PyObject *resultobj = 0;
44710 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44711 size_t arg2 ;
44712 wxMenu *result = 0 ;
44713 void *argp1 = 0 ;
44714 int res1 = 0 ;
44715 size_t val2 ;
44716 int ecode2 = 0 ;
44717 PyObject * obj0 = 0 ;
44718 PyObject * obj1 = 0 ;
44719 char * kwnames[] = {
44720 (char *) "self",(char *) "pos", NULL
44721 };
44722
44723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44725 if (!SWIG_IsOK(res1)) {
44726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44727 }
44728 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44729 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44730 if (!SWIG_IsOK(ecode2)) {
44731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44732 }
44733 arg2 = static_cast< size_t >(val2);
44734 {
44735 PyThreadState* __tstate = wxPyBeginAllowThreads();
44736 result = (wxMenu *)(arg1)->Remove(arg2);
44737 wxPyEndAllowThreads(__tstate);
44738 if (PyErr_Occurred()) SWIG_fail;
44739 }
44740 {
44741 resultobj = wxPyMake_wxObject(result, 0);
44742 }
44743 return resultobj;
44744 fail:
44745 return NULL;
44746 }
44747
44748
44749 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44750 PyObject *resultobj = 0;
44751 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44752 size_t arg2 ;
44753 bool arg3 ;
44754 void *argp1 = 0 ;
44755 int res1 = 0 ;
44756 size_t val2 ;
44757 int ecode2 = 0 ;
44758 bool val3 ;
44759 int ecode3 = 0 ;
44760 PyObject * obj0 = 0 ;
44761 PyObject * obj1 = 0 ;
44762 PyObject * obj2 = 0 ;
44763 char * kwnames[] = {
44764 (char *) "self",(char *) "pos",(char *) "enable", NULL
44765 };
44766
44767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44769 if (!SWIG_IsOK(res1)) {
44770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44771 }
44772 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44773 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44774 if (!SWIG_IsOK(ecode2)) {
44775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44776 }
44777 arg2 = static_cast< size_t >(val2);
44778 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44779 if (!SWIG_IsOK(ecode3)) {
44780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44781 }
44782 arg3 = static_cast< bool >(val3);
44783 {
44784 PyThreadState* __tstate = wxPyBeginAllowThreads();
44785 (arg1)->EnableTop(arg2,arg3);
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 resultobj = SWIG_Py_Void();
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44797 PyObject *resultobj = 0;
44798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44799 size_t arg2 ;
44800 bool result;
44801 void *argp1 = 0 ;
44802 int res1 = 0 ;
44803 size_t val2 ;
44804 int ecode2 = 0 ;
44805 PyObject * obj0 = 0 ;
44806 PyObject * obj1 = 0 ;
44807 char * kwnames[] = {
44808 (char *) "self",(char *) "pos", NULL
44809 };
44810
44811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44813 if (!SWIG_IsOK(res1)) {
44814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44815 }
44816 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44817 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44818 if (!SWIG_IsOK(ecode2)) {
44819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44820 }
44821 arg2 = static_cast< size_t >(val2);
44822 {
44823 PyThreadState* __tstate = wxPyBeginAllowThreads();
44824 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44825 wxPyEndAllowThreads(__tstate);
44826 if (PyErr_Occurred()) SWIG_fail;
44827 }
44828 {
44829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44830 }
44831 return resultobj;
44832 fail:
44833 return NULL;
44834 }
44835
44836
44837 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44838 PyObject *resultobj = 0;
44839 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44840 size_t arg2 ;
44841 wxString *arg3 = 0 ;
44842 void *argp1 = 0 ;
44843 int res1 = 0 ;
44844 size_t val2 ;
44845 int ecode2 = 0 ;
44846 bool temp3 = false ;
44847 PyObject * obj0 = 0 ;
44848 PyObject * obj1 = 0 ;
44849 PyObject * obj2 = 0 ;
44850 char * kwnames[] = {
44851 (char *) "self",(char *) "pos",(char *) "label", NULL
44852 };
44853
44854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44856 if (!SWIG_IsOK(res1)) {
44857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44858 }
44859 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44860 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44861 if (!SWIG_IsOK(ecode2)) {
44862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44863 }
44864 arg2 = static_cast< size_t >(val2);
44865 {
44866 arg3 = wxString_in_helper(obj2);
44867 if (arg3 == NULL) SWIG_fail;
44868 temp3 = true;
44869 }
44870 {
44871 PyThreadState* __tstate = wxPyBeginAllowThreads();
44872 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44873 wxPyEndAllowThreads(__tstate);
44874 if (PyErr_Occurred()) SWIG_fail;
44875 }
44876 resultobj = SWIG_Py_Void();
44877 {
44878 if (temp3)
44879 delete arg3;
44880 }
44881 return resultobj;
44882 fail:
44883 {
44884 if (temp3)
44885 delete arg3;
44886 }
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj = 0;
44893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44894 size_t arg2 ;
44895 wxString result;
44896 void *argp1 = 0 ;
44897 int res1 = 0 ;
44898 size_t val2 ;
44899 int ecode2 = 0 ;
44900 PyObject * obj0 = 0 ;
44901 PyObject * obj1 = 0 ;
44902 char * kwnames[] = {
44903 (char *) "self",(char *) "pos", NULL
44904 };
44905
44906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44908 if (!SWIG_IsOK(res1)) {
44909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44910 }
44911 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44912 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44913 if (!SWIG_IsOK(ecode2)) {
44914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44915 }
44916 arg2 = static_cast< size_t >(val2);
44917 {
44918 PyThreadState* __tstate = wxPyBeginAllowThreads();
44919 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44920 wxPyEndAllowThreads(__tstate);
44921 if (PyErr_Occurred()) SWIG_fail;
44922 }
44923 {
44924 #if wxUSE_UNICODE
44925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44926 #else
44927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44928 #endif
44929 }
44930 return resultobj;
44931 fail:
44932 return NULL;
44933 }
44934
44935
44936 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44937 PyObject *resultobj = 0;
44938 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44939 wxString *arg2 = 0 ;
44940 wxString *arg3 = 0 ;
44941 int result;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 bool temp2 = false ;
44945 bool temp3 = false ;
44946 PyObject * obj0 = 0 ;
44947 PyObject * obj1 = 0 ;
44948 PyObject * obj2 = 0 ;
44949 char * kwnames[] = {
44950 (char *) "self",(char *) "menu",(char *) "item", NULL
44951 };
44952
44953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44955 if (!SWIG_IsOK(res1)) {
44956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44957 }
44958 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44959 {
44960 arg2 = wxString_in_helper(obj1);
44961 if (arg2 == NULL) SWIG_fail;
44962 temp2 = true;
44963 }
44964 {
44965 arg3 = wxString_in_helper(obj2);
44966 if (arg3 == NULL) SWIG_fail;
44967 temp3 = true;
44968 }
44969 {
44970 PyThreadState* __tstate = wxPyBeginAllowThreads();
44971 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44972 wxPyEndAllowThreads(__tstate);
44973 if (PyErr_Occurred()) SWIG_fail;
44974 }
44975 resultobj = SWIG_From_int(static_cast< int >(result));
44976 {
44977 if (temp2)
44978 delete arg2;
44979 }
44980 {
44981 if (temp3)
44982 delete arg3;
44983 }
44984 return resultobj;
44985 fail:
44986 {
44987 if (temp2)
44988 delete arg2;
44989 }
44990 {
44991 if (temp3)
44992 delete arg3;
44993 }
44994 return NULL;
44995 }
44996
44997
44998 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44999 PyObject *resultobj = 0;
45000 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45001 int arg2 ;
45002 wxMenuItem *result = 0 ;
45003 void *argp1 = 0 ;
45004 int res1 = 0 ;
45005 int val2 ;
45006 int ecode2 = 0 ;
45007 PyObject * obj0 = 0 ;
45008 PyObject * obj1 = 0 ;
45009 char * kwnames[] = {
45010 (char *) "self",(char *) "id", NULL
45011 };
45012
45013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45015 if (!SWIG_IsOK(res1)) {
45016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45017 }
45018 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45019 ecode2 = SWIG_AsVal_int(obj1, &val2);
45020 if (!SWIG_IsOK(ecode2)) {
45021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45022 }
45023 arg2 = static_cast< int >(val2);
45024 {
45025 PyThreadState* __tstate = wxPyBeginAllowThreads();
45026 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45027 wxPyEndAllowThreads(__tstate);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 }
45030 {
45031 resultobj = wxPyMake_wxObject(result, (bool)0);
45032 }
45033 return resultobj;
45034 fail:
45035 return NULL;
45036 }
45037
45038
45039 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45040 PyObject *resultobj = 0;
45041 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45042 wxString *arg2 = 0 ;
45043 int result;
45044 void *argp1 = 0 ;
45045 int res1 = 0 ;
45046 bool temp2 = false ;
45047 PyObject * obj0 = 0 ;
45048 PyObject * obj1 = 0 ;
45049 char * kwnames[] = {
45050 (char *) "self",(char *) "title", NULL
45051 };
45052
45053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45055 if (!SWIG_IsOK(res1)) {
45056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45057 }
45058 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45059 {
45060 arg2 = wxString_in_helper(obj1);
45061 if (arg2 == NULL) SWIG_fail;
45062 temp2 = true;
45063 }
45064 {
45065 PyThreadState* __tstate = wxPyBeginAllowThreads();
45066 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45067 wxPyEndAllowThreads(__tstate);
45068 if (PyErr_Occurred()) SWIG_fail;
45069 }
45070 resultobj = SWIG_From_int(static_cast< int >(result));
45071 {
45072 if (temp2)
45073 delete arg2;
45074 }
45075 return resultobj;
45076 fail:
45077 {
45078 if (temp2)
45079 delete arg2;
45080 }
45081 return NULL;
45082 }
45083
45084
45085 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45086 PyObject *resultobj = 0;
45087 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45088 int arg2 ;
45089 bool arg3 ;
45090 void *argp1 = 0 ;
45091 int res1 = 0 ;
45092 int val2 ;
45093 int ecode2 = 0 ;
45094 bool val3 ;
45095 int ecode3 = 0 ;
45096 PyObject * obj0 = 0 ;
45097 PyObject * obj1 = 0 ;
45098 PyObject * obj2 = 0 ;
45099 char * kwnames[] = {
45100 (char *) "self",(char *) "id",(char *) "enable", NULL
45101 };
45102
45103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45105 if (!SWIG_IsOK(res1)) {
45106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45107 }
45108 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45109 ecode2 = SWIG_AsVal_int(obj1, &val2);
45110 if (!SWIG_IsOK(ecode2)) {
45111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45112 }
45113 arg2 = static_cast< int >(val2);
45114 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45115 if (!SWIG_IsOK(ecode3)) {
45116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45117 }
45118 arg3 = static_cast< bool >(val3);
45119 {
45120 PyThreadState* __tstate = wxPyBeginAllowThreads();
45121 (arg1)->Enable(arg2,arg3);
45122 wxPyEndAllowThreads(__tstate);
45123 if (PyErr_Occurred()) SWIG_fail;
45124 }
45125 resultobj = SWIG_Py_Void();
45126 return resultobj;
45127 fail:
45128 return NULL;
45129 }
45130
45131
45132 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45133 PyObject *resultobj = 0;
45134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45135 int arg2 ;
45136 bool arg3 ;
45137 void *argp1 = 0 ;
45138 int res1 = 0 ;
45139 int val2 ;
45140 int ecode2 = 0 ;
45141 bool val3 ;
45142 int ecode3 = 0 ;
45143 PyObject * obj0 = 0 ;
45144 PyObject * obj1 = 0 ;
45145 PyObject * obj2 = 0 ;
45146 char * kwnames[] = {
45147 (char *) "self",(char *) "id",(char *) "check", NULL
45148 };
45149
45150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45152 if (!SWIG_IsOK(res1)) {
45153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45154 }
45155 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45156 ecode2 = SWIG_AsVal_int(obj1, &val2);
45157 if (!SWIG_IsOK(ecode2)) {
45158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45159 }
45160 arg2 = static_cast< int >(val2);
45161 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45162 if (!SWIG_IsOK(ecode3)) {
45163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45164 }
45165 arg3 = static_cast< bool >(val3);
45166 {
45167 PyThreadState* __tstate = wxPyBeginAllowThreads();
45168 (arg1)->Check(arg2,arg3);
45169 wxPyEndAllowThreads(__tstate);
45170 if (PyErr_Occurred()) SWIG_fail;
45171 }
45172 resultobj = SWIG_Py_Void();
45173 return resultobj;
45174 fail:
45175 return NULL;
45176 }
45177
45178
45179 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45180 PyObject *resultobj = 0;
45181 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45182 int arg2 ;
45183 bool result;
45184 void *argp1 = 0 ;
45185 int res1 = 0 ;
45186 int val2 ;
45187 int ecode2 = 0 ;
45188 PyObject * obj0 = 0 ;
45189 PyObject * obj1 = 0 ;
45190 char * kwnames[] = {
45191 (char *) "self",(char *) "id", NULL
45192 };
45193
45194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45196 if (!SWIG_IsOK(res1)) {
45197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45198 }
45199 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45200 ecode2 = SWIG_AsVal_int(obj1, &val2);
45201 if (!SWIG_IsOK(ecode2)) {
45202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45203 }
45204 arg2 = static_cast< int >(val2);
45205 {
45206 PyThreadState* __tstate = wxPyBeginAllowThreads();
45207 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45208 wxPyEndAllowThreads(__tstate);
45209 if (PyErr_Occurred()) SWIG_fail;
45210 }
45211 {
45212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45213 }
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj = 0;
45222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45223 int arg2 ;
45224 bool result;
45225 void *argp1 = 0 ;
45226 int res1 = 0 ;
45227 int val2 ;
45228 int ecode2 = 0 ;
45229 PyObject * obj0 = 0 ;
45230 PyObject * obj1 = 0 ;
45231 char * kwnames[] = {
45232 (char *) "self",(char *) "id", NULL
45233 };
45234
45235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45237 if (!SWIG_IsOK(res1)) {
45238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45239 }
45240 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45241 ecode2 = SWIG_AsVal_int(obj1, &val2);
45242 if (!SWIG_IsOK(ecode2)) {
45243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45244 }
45245 arg2 = static_cast< int >(val2);
45246 {
45247 PyThreadState* __tstate = wxPyBeginAllowThreads();
45248 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 {
45253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45254 }
45255 return resultobj;
45256 fail:
45257 return NULL;
45258 }
45259
45260
45261 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45262 PyObject *resultobj = 0;
45263 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45264 int arg2 ;
45265 wxString *arg3 = 0 ;
45266 void *argp1 = 0 ;
45267 int res1 = 0 ;
45268 int val2 ;
45269 int ecode2 = 0 ;
45270 bool temp3 = false ;
45271 PyObject * obj0 = 0 ;
45272 PyObject * obj1 = 0 ;
45273 PyObject * obj2 = 0 ;
45274 char * kwnames[] = {
45275 (char *) "self",(char *) "id",(char *) "label", NULL
45276 };
45277
45278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45280 if (!SWIG_IsOK(res1)) {
45281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45282 }
45283 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45284 ecode2 = SWIG_AsVal_int(obj1, &val2);
45285 if (!SWIG_IsOK(ecode2)) {
45286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45287 }
45288 arg2 = static_cast< int >(val2);
45289 {
45290 arg3 = wxString_in_helper(obj2);
45291 if (arg3 == NULL) SWIG_fail;
45292 temp3 = true;
45293 }
45294 {
45295 PyThreadState* __tstate = wxPyBeginAllowThreads();
45296 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45297 wxPyEndAllowThreads(__tstate);
45298 if (PyErr_Occurred()) SWIG_fail;
45299 }
45300 resultobj = SWIG_Py_Void();
45301 {
45302 if (temp3)
45303 delete arg3;
45304 }
45305 return resultobj;
45306 fail:
45307 {
45308 if (temp3)
45309 delete arg3;
45310 }
45311 return NULL;
45312 }
45313
45314
45315 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45316 PyObject *resultobj = 0;
45317 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45318 int arg2 ;
45319 wxString result;
45320 void *argp1 = 0 ;
45321 int res1 = 0 ;
45322 int val2 ;
45323 int ecode2 = 0 ;
45324 PyObject * obj0 = 0 ;
45325 PyObject * obj1 = 0 ;
45326 char * kwnames[] = {
45327 (char *) "self",(char *) "id", NULL
45328 };
45329
45330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45332 if (!SWIG_IsOK(res1)) {
45333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45334 }
45335 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45336 ecode2 = SWIG_AsVal_int(obj1, &val2);
45337 if (!SWIG_IsOK(ecode2)) {
45338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45339 }
45340 arg2 = static_cast< int >(val2);
45341 {
45342 PyThreadState* __tstate = wxPyBeginAllowThreads();
45343 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45344 wxPyEndAllowThreads(__tstate);
45345 if (PyErr_Occurred()) SWIG_fail;
45346 }
45347 {
45348 #if wxUSE_UNICODE
45349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45350 #else
45351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45352 #endif
45353 }
45354 return resultobj;
45355 fail:
45356 return NULL;
45357 }
45358
45359
45360 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45361 PyObject *resultobj = 0;
45362 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45363 int arg2 ;
45364 wxString *arg3 = 0 ;
45365 void *argp1 = 0 ;
45366 int res1 = 0 ;
45367 int val2 ;
45368 int ecode2 = 0 ;
45369 bool temp3 = false ;
45370 PyObject * obj0 = 0 ;
45371 PyObject * obj1 = 0 ;
45372 PyObject * obj2 = 0 ;
45373 char * kwnames[] = {
45374 (char *) "self",(char *) "id",(char *) "helpString", NULL
45375 };
45376
45377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45379 if (!SWIG_IsOK(res1)) {
45380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45381 }
45382 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45383 ecode2 = SWIG_AsVal_int(obj1, &val2);
45384 if (!SWIG_IsOK(ecode2)) {
45385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45386 }
45387 arg2 = static_cast< int >(val2);
45388 {
45389 arg3 = wxString_in_helper(obj2);
45390 if (arg3 == NULL) SWIG_fail;
45391 temp3 = true;
45392 }
45393 {
45394 PyThreadState* __tstate = wxPyBeginAllowThreads();
45395 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45396 wxPyEndAllowThreads(__tstate);
45397 if (PyErr_Occurred()) SWIG_fail;
45398 }
45399 resultobj = SWIG_Py_Void();
45400 {
45401 if (temp3)
45402 delete arg3;
45403 }
45404 return resultobj;
45405 fail:
45406 {
45407 if (temp3)
45408 delete arg3;
45409 }
45410 return NULL;
45411 }
45412
45413
45414 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45415 PyObject *resultobj = 0;
45416 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45417 int arg2 ;
45418 wxString result;
45419 void *argp1 = 0 ;
45420 int res1 = 0 ;
45421 int val2 ;
45422 int ecode2 = 0 ;
45423 PyObject * obj0 = 0 ;
45424 PyObject * obj1 = 0 ;
45425 char * kwnames[] = {
45426 (char *) "self",(char *) "id", NULL
45427 };
45428
45429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45431 if (!SWIG_IsOK(res1)) {
45432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45433 }
45434 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45435 ecode2 = SWIG_AsVal_int(obj1, &val2);
45436 if (!SWIG_IsOK(ecode2)) {
45437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45438 }
45439 arg2 = static_cast< int >(val2);
45440 {
45441 PyThreadState* __tstate = wxPyBeginAllowThreads();
45442 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45443 wxPyEndAllowThreads(__tstate);
45444 if (PyErr_Occurred()) SWIG_fail;
45445 }
45446 {
45447 #if wxUSE_UNICODE
45448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45449 #else
45450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45451 #endif
45452 }
45453 return resultobj;
45454 fail:
45455 return NULL;
45456 }
45457
45458
45459 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45460 PyObject *resultobj = 0;
45461 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45462 wxFrame *result = 0 ;
45463 void *argp1 = 0 ;
45464 int res1 = 0 ;
45465 PyObject *swig_obj[1] ;
45466
45467 if (!args) SWIG_fail;
45468 swig_obj[0] = args;
45469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45470 if (!SWIG_IsOK(res1)) {
45471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45472 }
45473 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45474 {
45475 PyThreadState* __tstate = wxPyBeginAllowThreads();
45476 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45477 wxPyEndAllowThreads(__tstate);
45478 if (PyErr_Occurred()) SWIG_fail;
45479 }
45480 {
45481 resultobj = wxPyMake_wxObject(result, (bool)0);
45482 }
45483 return resultobj;
45484 fail:
45485 return NULL;
45486 }
45487
45488
45489 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45490 PyObject *resultobj = 0;
45491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45492 bool result;
45493 void *argp1 = 0 ;
45494 int res1 = 0 ;
45495 PyObject *swig_obj[1] ;
45496
45497 if (!args) SWIG_fail;
45498 swig_obj[0] = args;
45499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45500 if (!SWIG_IsOK(res1)) {
45501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45502 }
45503 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45504 {
45505 PyThreadState* __tstate = wxPyBeginAllowThreads();
45506 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45507 wxPyEndAllowThreads(__tstate);
45508 if (PyErr_Occurred()) SWIG_fail;
45509 }
45510 {
45511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45512 }
45513 return resultobj;
45514 fail:
45515 return NULL;
45516 }
45517
45518
45519 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45520 PyObject *resultobj = 0;
45521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45522 wxFrame *arg2 = (wxFrame *) 0 ;
45523 void *argp1 = 0 ;
45524 int res1 = 0 ;
45525 void *argp2 = 0 ;
45526 int res2 = 0 ;
45527 PyObject * obj0 = 0 ;
45528 PyObject * obj1 = 0 ;
45529 char * kwnames[] = {
45530 (char *) "self",(char *) "frame", NULL
45531 };
45532
45533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45535 if (!SWIG_IsOK(res1)) {
45536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45537 }
45538 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45540 if (!SWIG_IsOK(res2)) {
45541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45542 }
45543 arg2 = reinterpret_cast< wxFrame * >(argp2);
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 (arg1)->Attach(arg2);
45547 wxPyEndAllowThreads(__tstate);
45548 if (PyErr_Occurred()) SWIG_fail;
45549 }
45550 resultobj = SWIG_Py_Void();
45551 return resultobj;
45552 fail:
45553 return NULL;
45554 }
45555
45556
45557 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45558 PyObject *resultobj = 0;
45559 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45560 void *argp1 = 0 ;
45561 int res1 = 0 ;
45562 PyObject *swig_obj[1] ;
45563
45564 if (!args) SWIG_fail;
45565 swig_obj[0] = args;
45566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45567 if (!SWIG_IsOK(res1)) {
45568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45569 }
45570 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45571 {
45572 PyThreadState* __tstate = wxPyBeginAllowThreads();
45573 (arg1)->Detach();
45574 wxPyEndAllowThreads(__tstate);
45575 if (PyErr_Occurred()) SWIG_fail;
45576 }
45577 resultobj = SWIG_Py_Void();
45578 return resultobj;
45579 fail:
45580 return NULL;
45581 }
45582
45583
45584 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45585 PyObject *resultobj = 0;
45586 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 PyObject *swig_obj[1] ;
45590
45591 if (!args) SWIG_fail;
45592 swig_obj[0] = args;
45593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45594 if (!SWIG_IsOK(res1)) {
45595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45596 }
45597 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45598 {
45599 PyThreadState* __tstate = wxPyBeginAllowThreads();
45600 (arg1)->UpdateMenus();
45601 wxPyEndAllowThreads(__tstate);
45602 if (PyErr_Occurred()) SWIG_fail;
45603 }
45604 resultobj = SWIG_Py_Void();
45605 return resultobj;
45606 fail:
45607 return NULL;
45608 }
45609
45610
45611 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45612 PyObject *resultobj = 0;
45613 bool arg1 ;
45614 bool val1 ;
45615 int ecode1 = 0 ;
45616 PyObject * obj0 = 0 ;
45617 char * kwnames[] = {
45618 (char *) "enable", NULL
45619 };
45620
45621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45622 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45623 if (!SWIG_IsOK(ecode1)) {
45624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45625 }
45626 arg1 = static_cast< bool >(val1);
45627 {
45628 PyThreadState* __tstate = wxPyBeginAllowThreads();
45629 wxMenuBar_SetAutoWindowMenu(arg1);
45630 wxPyEndAllowThreads(__tstate);
45631 if (PyErr_Occurred()) SWIG_fail;
45632 }
45633 resultobj = SWIG_Py_Void();
45634 return resultobj;
45635 fail:
45636 return NULL;
45637 }
45638
45639
45640 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45641 PyObject *resultobj = 0;
45642 bool result;
45643
45644 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45645 {
45646 PyThreadState* __tstate = wxPyBeginAllowThreads();
45647 result = (bool)wxMenuBar_GetAutoWindowMenu();
45648 wxPyEndAllowThreads(__tstate);
45649 if (PyErr_Occurred()) SWIG_fail;
45650 }
45651 {
45652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45653 }
45654 return resultobj;
45655 fail:
45656 return NULL;
45657 }
45658
45659
45660 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45661 PyObject *obj;
45662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45663 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45664 return SWIG_Py_Void();
45665 }
45666
45667 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45668 return SWIG_Python_InitShadowInstance(args);
45669 }
45670
45671 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45672 PyObject *resultobj = 0;
45673 wxMenu *arg1 = (wxMenu *) NULL ;
45674 int arg2 = (int) wxID_ANY ;
45675 wxString const &arg3_defvalue = wxPyEmptyString ;
45676 wxString *arg3 = (wxString *) &arg3_defvalue ;
45677 wxString const &arg4_defvalue = wxPyEmptyString ;
45678 wxString *arg4 = (wxString *) &arg4_defvalue ;
45679 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45680 wxMenu *arg6 = (wxMenu *) NULL ;
45681 wxMenuItem *result = 0 ;
45682 void *argp1 = 0 ;
45683 int res1 = 0 ;
45684 int val2 ;
45685 int ecode2 = 0 ;
45686 bool temp3 = false ;
45687 bool temp4 = false ;
45688 int val5 ;
45689 int ecode5 = 0 ;
45690 void *argp6 = 0 ;
45691 int res6 = 0 ;
45692 PyObject * obj0 = 0 ;
45693 PyObject * obj1 = 0 ;
45694 PyObject * obj2 = 0 ;
45695 PyObject * obj3 = 0 ;
45696 PyObject * obj4 = 0 ;
45697 PyObject * obj5 = 0 ;
45698 char * kwnames[] = {
45699 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45700 };
45701
45702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45703 if (obj0) {
45704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45705 if (!SWIG_IsOK(res1)) {
45706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45707 }
45708 arg1 = reinterpret_cast< wxMenu * >(argp1);
45709 }
45710 if (obj1) {
45711 ecode2 = SWIG_AsVal_int(obj1, &val2);
45712 if (!SWIG_IsOK(ecode2)) {
45713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45714 }
45715 arg2 = static_cast< int >(val2);
45716 }
45717 if (obj2) {
45718 {
45719 arg3 = wxString_in_helper(obj2);
45720 if (arg3 == NULL) SWIG_fail;
45721 temp3 = true;
45722 }
45723 }
45724 if (obj3) {
45725 {
45726 arg4 = wxString_in_helper(obj3);
45727 if (arg4 == NULL) SWIG_fail;
45728 temp4 = true;
45729 }
45730 }
45731 if (obj4) {
45732 ecode5 = SWIG_AsVal_int(obj4, &val5);
45733 if (!SWIG_IsOK(ecode5)) {
45734 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45735 }
45736 arg5 = static_cast< wxItemKind >(val5);
45737 }
45738 if (obj5) {
45739 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45740 if (!SWIG_IsOK(res6)) {
45741 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45742 }
45743 arg6 = reinterpret_cast< wxMenu * >(argp6);
45744 }
45745 {
45746 PyThreadState* __tstate = wxPyBeginAllowThreads();
45747 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45752 {
45753 if (temp3)
45754 delete arg3;
45755 }
45756 {
45757 if (temp4)
45758 delete arg4;
45759 }
45760 return resultobj;
45761 fail:
45762 {
45763 if (temp3)
45764 delete arg3;
45765 }
45766 {
45767 if (temp4)
45768 delete arg4;
45769 }
45770 return NULL;
45771 }
45772
45773
45774 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45775 PyObject *resultobj = 0;
45776 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45777 void *argp1 = 0 ;
45778 int res1 = 0 ;
45779 PyObject *swig_obj[1] ;
45780
45781 if (!args) SWIG_fail;
45782 swig_obj[0] = args;
45783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45784 if (!SWIG_IsOK(res1)) {
45785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45786 }
45787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45788 {
45789 PyThreadState* __tstate = wxPyBeginAllowThreads();
45790 delete arg1;
45791
45792 wxPyEndAllowThreads(__tstate);
45793 if (PyErr_Occurred()) SWIG_fail;
45794 }
45795 resultobj = SWIG_Py_Void();
45796 return resultobj;
45797 fail:
45798 return NULL;
45799 }
45800
45801
45802 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45803 PyObject *resultobj = 0;
45804 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45805 wxMenu *result = 0 ;
45806 void *argp1 = 0 ;
45807 int res1 = 0 ;
45808 PyObject *swig_obj[1] ;
45809
45810 if (!args) SWIG_fail;
45811 swig_obj[0] = args;
45812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45813 if (!SWIG_IsOK(res1)) {
45814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45815 }
45816 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45817 {
45818 PyThreadState* __tstate = wxPyBeginAllowThreads();
45819 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45820 wxPyEndAllowThreads(__tstate);
45821 if (PyErr_Occurred()) SWIG_fail;
45822 }
45823 {
45824 resultobj = wxPyMake_wxObject(result, 0);
45825 }
45826 return resultobj;
45827 fail:
45828 return NULL;
45829 }
45830
45831
45832 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45833 PyObject *resultobj = 0;
45834 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45835 wxMenu *arg2 = (wxMenu *) 0 ;
45836 void *argp1 = 0 ;
45837 int res1 = 0 ;
45838 void *argp2 = 0 ;
45839 int res2 = 0 ;
45840 PyObject * obj0 = 0 ;
45841 PyObject * obj1 = 0 ;
45842 char * kwnames[] = {
45843 (char *) "self",(char *) "menu", NULL
45844 };
45845
45846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45848 if (!SWIG_IsOK(res1)) {
45849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45850 }
45851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45853 if (!SWIG_IsOK(res2)) {
45854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45855 }
45856 arg2 = reinterpret_cast< wxMenu * >(argp2);
45857 {
45858 PyThreadState* __tstate = wxPyBeginAllowThreads();
45859 (arg1)->SetMenu(arg2);
45860 wxPyEndAllowThreads(__tstate);
45861 if (PyErr_Occurred()) SWIG_fail;
45862 }
45863 resultobj = SWIG_Py_Void();
45864 return resultobj;
45865 fail:
45866 return NULL;
45867 }
45868
45869
45870 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45871 PyObject *resultobj = 0;
45872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45873 int arg2 ;
45874 void *argp1 = 0 ;
45875 int res1 = 0 ;
45876 int val2 ;
45877 int ecode2 = 0 ;
45878 PyObject * obj0 = 0 ;
45879 PyObject * obj1 = 0 ;
45880 char * kwnames[] = {
45881 (char *) "self",(char *) "id", NULL
45882 };
45883
45884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45886 if (!SWIG_IsOK(res1)) {
45887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45888 }
45889 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45890 ecode2 = SWIG_AsVal_int(obj1, &val2);
45891 if (!SWIG_IsOK(ecode2)) {
45892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45893 }
45894 arg2 = static_cast< int >(val2);
45895 {
45896 PyThreadState* __tstate = wxPyBeginAllowThreads();
45897 (arg1)->SetId(arg2);
45898 wxPyEndAllowThreads(__tstate);
45899 if (PyErr_Occurred()) SWIG_fail;
45900 }
45901 resultobj = SWIG_Py_Void();
45902 return resultobj;
45903 fail:
45904 return NULL;
45905 }
45906
45907
45908 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45909 PyObject *resultobj = 0;
45910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45911 int result;
45912 void *argp1 = 0 ;
45913 int res1 = 0 ;
45914 PyObject *swig_obj[1] ;
45915
45916 if (!args) SWIG_fail;
45917 swig_obj[0] = args;
45918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45919 if (!SWIG_IsOK(res1)) {
45920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45921 }
45922 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45923 {
45924 PyThreadState* __tstate = wxPyBeginAllowThreads();
45925 result = (int)((wxMenuItem const *)arg1)->GetId();
45926 wxPyEndAllowThreads(__tstate);
45927 if (PyErr_Occurred()) SWIG_fail;
45928 }
45929 resultobj = SWIG_From_int(static_cast< int >(result));
45930 return resultobj;
45931 fail:
45932 return NULL;
45933 }
45934
45935
45936 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45937 PyObject *resultobj = 0;
45938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45939 bool result;
45940 void *argp1 = 0 ;
45941 int res1 = 0 ;
45942 PyObject *swig_obj[1] ;
45943
45944 if (!args) SWIG_fail;
45945 swig_obj[0] = args;
45946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45947 if (!SWIG_IsOK(res1)) {
45948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45949 }
45950 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45951 {
45952 PyThreadState* __tstate = wxPyBeginAllowThreads();
45953 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45954 wxPyEndAllowThreads(__tstate);
45955 if (PyErr_Occurred()) SWIG_fail;
45956 }
45957 {
45958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45959 }
45960 return resultobj;
45961 fail:
45962 return NULL;
45963 }
45964
45965
45966 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45967 PyObject *resultobj = 0;
45968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45969 wxString *arg2 = 0 ;
45970 void *argp1 = 0 ;
45971 int res1 = 0 ;
45972 bool temp2 = false ;
45973 PyObject * obj0 = 0 ;
45974 PyObject * obj1 = 0 ;
45975 char * kwnames[] = {
45976 (char *) "self",(char *) "str", NULL
45977 };
45978
45979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45981 if (!SWIG_IsOK(res1)) {
45982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45983 }
45984 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45985 {
45986 arg2 = wxString_in_helper(obj1);
45987 if (arg2 == NULL) SWIG_fail;
45988 temp2 = true;
45989 }
45990 {
45991 PyThreadState* __tstate = wxPyBeginAllowThreads();
45992 (arg1)->SetText((wxString const &)*arg2);
45993 wxPyEndAllowThreads(__tstate);
45994 if (PyErr_Occurred()) SWIG_fail;
45995 }
45996 resultobj = SWIG_Py_Void();
45997 {
45998 if (temp2)
45999 delete arg2;
46000 }
46001 return resultobj;
46002 fail:
46003 {
46004 if (temp2)
46005 delete arg2;
46006 }
46007 return NULL;
46008 }
46009
46010
46011 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46012 PyObject *resultobj = 0;
46013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46014 wxString result;
46015 void *argp1 = 0 ;
46016 int res1 = 0 ;
46017 PyObject *swig_obj[1] ;
46018
46019 if (!args) SWIG_fail;
46020 swig_obj[0] = args;
46021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46022 if (!SWIG_IsOK(res1)) {
46023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46024 }
46025 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46026 {
46027 PyThreadState* __tstate = wxPyBeginAllowThreads();
46028 result = ((wxMenuItem const *)arg1)->GetLabel();
46029 wxPyEndAllowThreads(__tstate);
46030 if (PyErr_Occurred()) SWIG_fail;
46031 }
46032 {
46033 #if wxUSE_UNICODE
46034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46035 #else
46036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46037 #endif
46038 }
46039 return resultobj;
46040 fail:
46041 return NULL;
46042 }
46043
46044
46045 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46046 PyObject *resultobj = 0;
46047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46048 wxString *result = 0 ;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 PyObject *swig_obj[1] ;
46052
46053 if (!args) SWIG_fail;
46054 swig_obj[0] = args;
46055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46056 if (!SWIG_IsOK(res1)) {
46057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46058 }
46059 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 {
46063 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46064 result = (wxString *) &_result_ref;
46065 }
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 {
46070 #if wxUSE_UNICODE
46071 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46072 #else
46073 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46074 #endif
46075 }
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46083 PyObject *resultobj = 0;
46084 wxString *arg1 = 0 ;
46085 wxString result;
46086 bool temp1 = false ;
46087 PyObject * obj0 = 0 ;
46088 char * kwnames[] = {
46089 (char *) "text", NULL
46090 };
46091
46092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46093 {
46094 arg1 = wxString_in_helper(obj0);
46095 if (arg1 == NULL) SWIG_fail;
46096 temp1 = true;
46097 }
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 {
46105 #if wxUSE_UNICODE
46106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46107 #else
46108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46109 #endif
46110 }
46111 {
46112 if (temp1)
46113 delete arg1;
46114 }
46115 return resultobj;
46116 fail:
46117 {
46118 if (temp1)
46119 delete arg1;
46120 }
46121 return NULL;
46122 }
46123
46124
46125 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46126 PyObject *resultobj = 0;
46127 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46128 wxItemKind result;
46129 void *argp1 = 0 ;
46130 int res1 = 0 ;
46131 PyObject *swig_obj[1] ;
46132
46133 if (!args) SWIG_fail;
46134 swig_obj[0] = args;
46135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46136 if (!SWIG_IsOK(res1)) {
46137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46138 }
46139 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46140 {
46141 PyThreadState* __tstate = wxPyBeginAllowThreads();
46142 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46143 wxPyEndAllowThreads(__tstate);
46144 if (PyErr_Occurred()) SWIG_fail;
46145 }
46146 resultobj = SWIG_From_int(static_cast< int >(result));
46147 return resultobj;
46148 fail:
46149 return NULL;
46150 }
46151
46152
46153 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46154 PyObject *resultobj = 0;
46155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46156 wxItemKind arg2 ;
46157 void *argp1 = 0 ;
46158 int res1 = 0 ;
46159 int val2 ;
46160 int ecode2 = 0 ;
46161 PyObject * obj0 = 0 ;
46162 PyObject * obj1 = 0 ;
46163 char * kwnames[] = {
46164 (char *) "self",(char *) "kind", NULL
46165 };
46166
46167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46169 if (!SWIG_IsOK(res1)) {
46170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46171 }
46172 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46173 ecode2 = SWIG_AsVal_int(obj1, &val2);
46174 if (!SWIG_IsOK(ecode2)) {
46175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46176 }
46177 arg2 = static_cast< wxItemKind >(val2);
46178 {
46179 PyThreadState* __tstate = wxPyBeginAllowThreads();
46180 (arg1)->SetKind(arg2);
46181 wxPyEndAllowThreads(__tstate);
46182 if (PyErr_Occurred()) SWIG_fail;
46183 }
46184 resultobj = SWIG_Py_Void();
46185 return resultobj;
46186 fail:
46187 return NULL;
46188 }
46189
46190
46191 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46192 PyObject *resultobj = 0;
46193 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46194 bool arg2 ;
46195 void *argp1 = 0 ;
46196 int res1 = 0 ;
46197 bool val2 ;
46198 int ecode2 = 0 ;
46199 PyObject * obj0 = 0 ;
46200 PyObject * obj1 = 0 ;
46201 char * kwnames[] = {
46202 (char *) "self",(char *) "checkable", NULL
46203 };
46204
46205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46207 if (!SWIG_IsOK(res1)) {
46208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46209 }
46210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46211 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46212 if (!SWIG_IsOK(ecode2)) {
46213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46214 }
46215 arg2 = static_cast< bool >(val2);
46216 {
46217 PyThreadState* __tstate = wxPyBeginAllowThreads();
46218 (arg1)->SetCheckable(arg2);
46219 wxPyEndAllowThreads(__tstate);
46220 if (PyErr_Occurred()) SWIG_fail;
46221 }
46222 resultobj = SWIG_Py_Void();
46223 return resultobj;
46224 fail:
46225 return NULL;
46226 }
46227
46228
46229 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46230 PyObject *resultobj = 0;
46231 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46232 bool result;
46233 void *argp1 = 0 ;
46234 int res1 = 0 ;
46235 PyObject *swig_obj[1] ;
46236
46237 if (!args) SWIG_fail;
46238 swig_obj[0] = args;
46239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46240 if (!SWIG_IsOK(res1)) {
46241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46242 }
46243 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46244 {
46245 PyThreadState* __tstate = wxPyBeginAllowThreads();
46246 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46247 wxPyEndAllowThreads(__tstate);
46248 if (PyErr_Occurred()) SWIG_fail;
46249 }
46250 {
46251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46252 }
46253 return resultobj;
46254 fail:
46255 return NULL;
46256 }
46257
46258
46259 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46260 PyObject *resultobj = 0;
46261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46262 bool result;
46263 void *argp1 = 0 ;
46264 int res1 = 0 ;
46265 PyObject *swig_obj[1] ;
46266
46267 if (!args) SWIG_fail;
46268 swig_obj[0] = args;
46269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46270 if (!SWIG_IsOK(res1)) {
46271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46272 }
46273 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46274 {
46275 PyThreadState* __tstate = wxPyBeginAllowThreads();
46276 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46277 wxPyEndAllowThreads(__tstate);
46278 if (PyErr_Occurred()) SWIG_fail;
46279 }
46280 {
46281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46282 }
46283 return resultobj;
46284 fail:
46285 return NULL;
46286 }
46287
46288
46289 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46290 PyObject *resultobj = 0;
46291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46292 wxMenu *arg2 = (wxMenu *) 0 ;
46293 void *argp1 = 0 ;
46294 int res1 = 0 ;
46295 void *argp2 = 0 ;
46296 int res2 = 0 ;
46297 PyObject * obj0 = 0 ;
46298 PyObject * obj1 = 0 ;
46299 char * kwnames[] = {
46300 (char *) "self",(char *) "menu", NULL
46301 };
46302
46303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46305 if (!SWIG_IsOK(res1)) {
46306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46307 }
46308 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46310 if (!SWIG_IsOK(res2)) {
46311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46312 }
46313 arg2 = reinterpret_cast< wxMenu * >(argp2);
46314 {
46315 PyThreadState* __tstate = wxPyBeginAllowThreads();
46316 (arg1)->SetSubMenu(arg2);
46317 wxPyEndAllowThreads(__tstate);
46318 if (PyErr_Occurred()) SWIG_fail;
46319 }
46320 resultobj = SWIG_Py_Void();
46321 return resultobj;
46322 fail:
46323 return NULL;
46324 }
46325
46326
46327 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46328 PyObject *resultobj = 0;
46329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46330 wxMenu *result = 0 ;
46331 void *argp1 = 0 ;
46332 int res1 = 0 ;
46333 PyObject *swig_obj[1] ;
46334
46335 if (!args) SWIG_fail;
46336 swig_obj[0] = args;
46337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46338 if (!SWIG_IsOK(res1)) {
46339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46340 }
46341 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46342 {
46343 PyThreadState* __tstate = wxPyBeginAllowThreads();
46344 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46345 wxPyEndAllowThreads(__tstate);
46346 if (PyErr_Occurred()) SWIG_fail;
46347 }
46348 {
46349 resultobj = wxPyMake_wxObject(result, 0);
46350 }
46351 return resultobj;
46352 fail:
46353 return NULL;
46354 }
46355
46356
46357 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46358 PyObject *resultobj = 0;
46359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46360 bool arg2 = (bool) true ;
46361 void *argp1 = 0 ;
46362 int res1 = 0 ;
46363 bool val2 ;
46364 int ecode2 = 0 ;
46365 PyObject * obj0 = 0 ;
46366 PyObject * obj1 = 0 ;
46367 char * kwnames[] = {
46368 (char *) "self",(char *) "enable", NULL
46369 };
46370
46371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46373 if (!SWIG_IsOK(res1)) {
46374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46375 }
46376 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46377 if (obj1) {
46378 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46379 if (!SWIG_IsOK(ecode2)) {
46380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46381 }
46382 arg2 = static_cast< bool >(val2);
46383 }
46384 {
46385 PyThreadState* __tstate = wxPyBeginAllowThreads();
46386 (arg1)->Enable(arg2);
46387 wxPyEndAllowThreads(__tstate);
46388 if (PyErr_Occurred()) SWIG_fail;
46389 }
46390 resultobj = SWIG_Py_Void();
46391 return resultobj;
46392 fail:
46393 return NULL;
46394 }
46395
46396
46397 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46398 PyObject *resultobj = 0;
46399 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46400 bool result;
46401 void *argp1 = 0 ;
46402 int res1 = 0 ;
46403 PyObject *swig_obj[1] ;
46404
46405 if (!args) SWIG_fail;
46406 swig_obj[0] = args;
46407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46408 if (!SWIG_IsOK(res1)) {
46409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46410 }
46411 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46412 {
46413 PyThreadState* __tstate = wxPyBeginAllowThreads();
46414 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46415 wxPyEndAllowThreads(__tstate);
46416 if (PyErr_Occurred()) SWIG_fail;
46417 }
46418 {
46419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46420 }
46421 return resultobj;
46422 fail:
46423 return NULL;
46424 }
46425
46426
46427 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46428 PyObject *resultobj = 0;
46429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46430 bool arg2 = (bool) true ;
46431 void *argp1 = 0 ;
46432 int res1 = 0 ;
46433 bool val2 ;
46434 int ecode2 = 0 ;
46435 PyObject * obj0 = 0 ;
46436 PyObject * obj1 = 0 ;
46437 char * kwnames[] = {
46438 (char *) "self",(char *) "check", NULL
46439 };
46440
46441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46443 if (!SWIG_IsOK(res1)) {
46444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46445 }
46446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46447 if (obj1) {
46448 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46449 if (!SWIG_IsOK(ecode2)) {
46450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46451 }
46452 arg2 = static_cast< bool >(val2);
46453 }
46454 {
46455 PyThreadState* __tstate = wxPyBeginAllowThreads();
46456 (arg1)->Check(arg2);
46457 wxPyEndAllowThreads(__tstate);
46458 if (PyErr_Occurred()) SWIG_fail;
46459 }
46460 resultobj = SWIG_Py_Void();
46461 return resultobj;
46462 fail:
46463 return NULL;
46464 }
46465
46466
46467 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46468 PyObject *resultobj = 0;
46469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46470 bool result;
46471 void *argp1 = 0 ;
46472 int res1 = 0 ;
46473 PyObject *swig_obj[1] ;
46474
46475 if (!args) SWIG_fail;
46476 swig_obj[0] = args;
46477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46478 if (!SWIG_IsOK(res1)) {
46479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46480 }
46481 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46482 {
46483 PyThreadState* __tstate = wxPyBeginAllowThreads();
46484 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46485 wxPyEndAllowThreads(__tstate);
46486 if (PyErr_Occurred()) SWIG_fail;
46487 }
46488 {
46489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46490 }
46491 return resultobj;
46492 fail:
46493 return NULL;
46494 }
46495
46496
46497 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46498 PyObject *resultobj = 0;
46499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46500 void *argp1 = 0 ;
46501 int res1 = 0 ;
46502 PyObject *swig_obj[1] ;
46503
46504 if (!args) SWIG_fail;
46505 swig_obj[0] = args;
46506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46507 if (!SWIG_IsOK(res1)) {
46508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46509 }
46510 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46511 {
46512 PyThreadState* __tstate = wxPyBeginAllowThreads();
46513 (arg1)->Toggle();
46514 wxPyEndAllowThreads(__tstate);
46515 if (PyErr_Occurred()) SWIG_fail;
46516 }
46517 resultobj = SWIG_Py_Void();
46518 return resultobj;
46519 fail:
46520 return NULL;
46521 }
46522
46523
46524 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46525 PyObject *resultobj = 0;
46526 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46527 wxString *arg2 = 0 ;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 bool temp2 = false ;
46531 PyObject * obj0 = 0 ;
46532 PyObject * obj1 = 0 ;
46533 char * kwnames[] = {
46534 (char *) "self",(char *) "str", NULL
46535 };
46536
46537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46539 if (!SWIG_IsOK(res1)) {
46540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46541 }
46542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46543 {
46544 arg2 = wxString_in_helper(obj1);
46545 if (arg2 == NULL) SWIG_fail;
46546 temp2 = true;
46547 }
46548 {
46549 PyThreadState* __tstate = wxPyBeginAllowThreads();
46550 (arg1)->SetHelp((wxString const &)*arg2);
46551 wxPyEndAllowThreads(__tstate);
46552 if (PyErr_Occurred()) SWIG_fail;
46553 }
46554 resultobj = SWIG_Py_Void();
46555 {
46556 if (temp2)
46557 delete arg2;
46558 }
46559 return resultobj;
46560 fail:
46561 {
46562 if (temp2)
46563 delete arg2;
46564 }
46565 return NULL;
46566 }
46567
46568
46569 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46570 PyObject *resultobj = 0;
46571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46572 wxString *result = 0 ;
46573 void *argp1 = 0 ;
46574 int res1 = 0 ;
46575 PyObject *swig_obj[1] ;
46576
46577 if (!args) SWIG_fail;
46578 swig_obj[0] = args;
46579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46580 if (!SWIG_IsOK(res1)) {
46581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46582 }
46583 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46584 {
46585 PyThreadState* __tstate = wxPyBeginAllowThreads();
46586 {
46587 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46588 result = (wxString *) &_result_ref;
46589 }
46590 wxPyEndAllowThreads(__tstate);
46591 if (PyErr_Occurred()) SWIG_fail;
46592 }
46593 {
46594 #if wxUSE_UNICODE
46595 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46596 #else
46597 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46598 #endif
46599 }
46600 return resultobj;
46601 fail:
46602 return NULL;
46603 }
46604
46605
46606 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46607 PyObject *resultobj = 0;
46608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46609 wxAcceleratorEntry *result = 0 ;
46610 void *argp1 = 0 ;
46611 int res1 = 0 ;
46612 PyObject *swig_obj[1] ;
46613
46614 if (!args) SWIG_fail;
46615 swig_obj[0] = args;
46616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46617 if (!SWIG_IsOK(res1)) {
46618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46619 }
46620 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46621 {
46622 PyThreadState* __tstate = wxPyBeginAllowThreads();
46623 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46624 wxPyEndAllowThreads(__tstate);
46625 if (PyErr_Occurred()) SWIG_fail;
46626 }
46627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46628 return resultobj;
46629 fail:
46630 return NULL;
46631 }
46632
46633
46634 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46635 PyObject *resultobj = 0;
46636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46637 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46638 void *argp1 = 0 ;
46639 int res1 = 0 ;
46640 void *argp2 = 0 ;
46641 int res2 = 0 ;
46642 PyObject * obj0 = 0 ;
46643 PyObject * obj1 = 0 ;
46644 char * kwnames[] = {
46645 (char *) "self",(char *) "accel", NULL
46646 };
46647
46648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46650 if (!SWIG_IsOK(res1)) {
46651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46652 }
46653 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46655 if (!SWIG_IsOK(res2)) {
46656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46657 }
46658 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46659 {
46660 PyThreadState* __tstate = wxPyBeginAllowThreads();
46661 (arg1)->SetAccel(arg2);
46662 wxPyEndAllowThreads(__tstate);
46663 if (PyErr_Occurred()) SWIG_fail;
46664 }
46665 resultobj = SWIG_Py_Void();
46666 return resultobj;
46667 fail:
46668 return NULL;
46669 }
46670
46671
46672 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46673 PyObject *resultobj = 0;
46674 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46675 wxBitmap *arg2 = 0 ;
46676 void *argp1 = 0 ;
46677 int res1 = 0 ;
46678 void *argp2 = 0 ;
46679 int res2 = 0 ;
46680 PyObject * obj0 = 0 ;
46681 PyObject * obj1 = 0 ;
46682 char * kwnames[] = {
46683 (char *) "self",(char *) "bitmap", NULL
46684 };
46685
46686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46688 if (!SWIG_IsOK(res1)) {
46689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46690 }
46691 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46692 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46693 if (!SWIG_IsOK(res2)) {
46694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46695 }
46696 if (!argp2) {
46697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46698 }
46699 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46700 {
46701 PyThreadState* __tstate = wxPyBeginAllowThreads();
46702 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46703 wxPyEndAllowThreads(__tstate);
46704 if (PyErr_Occurred()) SWIG_fail;
46705 }
46706 resultobj = SWIG_Py_Void();
46707 return resultobj;
46708 fail:
46709 return NULL;
46710 }
46711
46712
46713 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46714 PyObject *resultobj = 0;
46715 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46716 wxBitmap *result = 0 ;
46717 void *argp1 = 0 ;
46718 int res1 = 0 ;
46719 PyObject *swig_obj[1] ;
46720
46721 if (!args) SWIG_fail;
46722 swig_obj[0] = args;
46723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46724 if (!SWIG_IsOK(res1)) {
46725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46726 }
46727 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46728 {
46729 PyThreadState* __tstate = wxPyBeginAllowThreads();
46730 {
46731 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46732 result = (wxBitmap *) &_result_ref;
46733 }
46734 wxPyEndAllowThreads(__tstate);
46735 if (PyErr_Occurred()) SWIG_fail;
46736 }
46737 {
46738 wxBitmap* resultptr = new wxBitmap(*result);
46739 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46740 }
46741 return resultobj;
46742 fail:
46743 return NULL;
46744 }
46745
46746
46747 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46748 PyObject *resultobj = 0;
46749 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46750 wxFont *arg2 = 0 ;
46751 void *argp1 = 0 ;
46752 int res1 = 0 ;
46753 void *argp2 = 0 ;
46754 int res2 = 0 ;
46755 PyObject * obj0 = 0 ;
46756 PyObject * obj1 = 0 ;
46757 char * kwnames[] = {
46758 (char *) "self",(char *) "font", NULL
46759 };
46760
46761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46763 if (!SWIG_IsOK(res1)) {
46764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46765 }
46766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46768 if (!SWIG_IsOK(res2)) {
46769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46770 }
46771 if (!argp2) {
46772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46773 }
46774 arg2 = reinterpret_cast< wxFont * >(argp2);
46775 {
46776 PyThreadState* __tstate = wxPyBeginAllowThreads();
46777 (arg1)->SetFont((wxFont const &)*arg2);
46778 wxPyEndAllowThreads(__tstate);
46779 if (PyErr_Occurred()) SWIG_fail;
46780 }
46781 resultobj = SWIG_Py_Void();
46782 return resultobj;
46783 fail:
46784 return NULL;
46785 }
46786
46787
46788 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46789 PyObject *resultobj = 0;
46790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46791 wxFont result;
46792 void *argp1 = 0 ;
46793 int res1 = 0 ;
46794 PyObject *swig_obj[1] ;
46795
46796 if (!args) SWIG_fail;
46797 swig_obj[0] = args;
46798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46799 if (!SWIG_IsOK(res1)) {
46800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46801 }
46802 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46803 {
46804 PyThreadState* __tstate = wxPyBeginAllowThreads();
46805 result = (arg1)->GetFont();
46806 wxPyEndAllowThreads(__tstate);
46807 if (PyErr_Occurred()) SWIG_fail;
46808 }
46809 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46810 return resultobj;
46811 fail:
46812 return NULL;
46813 }
46814
46815
46816 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46817 PyObject *resultobj = 0;
46818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46819 wxColour *arg2 = 0 ;
46820 void *argp1 = 0 ;
46821 int res1 = 0 ;
46822 wxColour temp2 ;
46823 PyObject * obj0 = 0 ;
46824 PyObject * obj1 = 0 ;
46825 char * kwnames[] = {
46826 (char *) "self",(char *) "colText", NULL
46827 };
46828
46829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46831 if (!SWIG_IsOK(res1)) {
46832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46833 }
46834 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46835 {
46836 arg2 = &temp2;
46837 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46838 }
46839 {
46840 PyThreadState* __tstate = wxPyBeginAllowThreads();
46841 (arg1)->SetTextColour((wxColour const &)*arg2);
46842 wxPyEndAllowThreads(__tstate);
46843 if (PyErr_Occurred()) SWIG_fail;
46844 }
46845 resultobj = SWIG_Py_Void();
46846 return resultobj;
46847 fail:
46848 return NULL;
46849 }
46850
46851
46852 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46853 PyObject *resultobj = 0;
46854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46855 wxColour result;
46856 void *argp1 = 0 ;
46857 int res1 = 0 ;
46858 PyObject *swig_obj[1] ;
46859
46860 if (!args) SWIG_fail;
46861 swig_obj[0] = args;
46862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46863 if (!SWIG_IsOK(res1)) {
46864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46865 }
46866 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46867 {
46868 PyThreadState* __tstate = wxPyBeginAllowThreads();
46869 result = (arg1)->GetTextColour();
46870 wxPyEndAllowThreads(__tstate);
46871 if (PyErr_Occurred()) SWIG_fail;
46872 }
46873 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46874 return resultobj;
46875 fail:
46876 return NULL;
46877 }
46878
46879
46880 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46881 PyObject *resultobj = 0;
46882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46883 wxColour *arg2 = 0 ;
46884 void *argp1 = 0 ;
46885 int res1 = 0 ;
46886 wxColour temp2 ;
46887 PyObject * obj0 = 0 ;
46888 PyObject * obj1 = 0 ;
46889 char * kwnames[] = {
46890 (char *) "self",(char *) "colBack", NULL
46891 };
46892
46893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46895 if (!SWIG_IsOK(res1)) {
46896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46897 }
46898 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46899 {
46900 arg2 = &temp2;
46901 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46902 }
46903 {
46904 PyThreadState* __tstate = wxPyBeginAllowThreads();
46905 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46906 wxPyEndAllowThreads(__tstate);
46907 if (PyErr_Occurred()) SWIG_fail;
46908 }
46909 resultobj = SWIG_Py_Void();
46910 return resultobj;
46911 fail:
46912 return NULL;
46913 }
46914
46915
46916 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46917 PyObject *resultobj = 0;
46918 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46919 wxColour result;
46920 void *argp1 = 0 ;
46921 int res1 = 0 ;
46922 PyObject *swig_obj[1] ;
46923
46924 if (!args) SWIG_fail;
46925 swig_obj[0] = args;
46926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46927 if (!SWIG_IsOK(res1)) {
46928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46929 }
46930 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46931 {
46932 PyThreadState* __tstate = wxPyBeginAllowThreads();
46933 result = (arg1)->GetBackgroundColour();
46934 wxPyEndAllowThreads(__tstate);
46935 if (PyErr_Occurred()) SWIG_fail;
46936 }
46937 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46938 return resultobj;
46939 fail:
46940 return NULL;
46941 }
46942
46943
46944 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46945 PyObject *resultobj = 0;
46946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46947 wxBitmap *arg2 = 0 ;
46948 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46949 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46950 void *argp1 = 0 ;
46951 int res1 = 0 ;
46952 void *argp2 = 0 ;
46953 int res2 = 0 ;
46954 void *argp3 = 0 ;
46955 int res3 = 0 ;
46956 PyObject * obj0 = 0 ;
46957 PyObject * obj1 = 0 ;
46958 PyObject * obj2 = 0 ;
46959 char * kwnames[] = {
46960 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46961 };
46962
46963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46965 if (!SWIG_IsOK(res1)) {
46966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46967 }
46968 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46970 if (!SWIG_IsOK(res2)) {
46971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46972 }
46973 if (!argp2) {
46974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46975 }
46976 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46977 if (obj2) {
46978 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46979 if (!SWIG_IsOK(res3)) {
46980 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46981 }
46982 if (!argp3) {
46983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46984 }
46985 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46986 }
46987 {
46988 PyThreadState* __tstate = wxPyBeginAllowThreads();
46989 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46990 wxPyEndAllowThreads(__tstate);
46991 if (PyErr_Occurred()) SWIG_fail;
46992 }
46993 resultobj = SWIG_Py_Void();
46994 return resultobj;
46995 fail:
46996 return NULL;
46997 }
46998
46999
47000 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47001 PyObject *resultobj = 0;
47002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47003 wxBitmap *arg2 = 0 ;
47004 void *argp1 = 0 ;
47005 int res1 = 0 ;
47006 void *argp2 = 0 ;
47007 int res2 = 0 ;
47008 PyObject * obj0 = 0 ;
47009 PyObject * obj1 = 0 ;
47010 char * kwnames[] = {
47011 (char *) "self",(char *) "bmpDisabled", NULL
47012 };
47013
47014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47016 if (!SWIG_IsOK(res1)) {
47017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47018 }
47019 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47020 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47021 if (!SWIG_IsOK(res2)) {
47022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47023 }
47024 if (!argp2) {
47025 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47026 }
47027 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47028 {
47029 PyThreadState* __tstate = wxPyBeginAllowThreads();
47030 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47031 wxPyEndAllowThreads(__tstate);
47032 if (PyErr_Occurred()) SWIG_fail;
47033 }
47034 resultobj = SWIG_Py_Void();
47035 return resultobj;
47036 fail:
47037 return NULL;
47038 }
47039
47040
47041 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47042 PyObject *resultobj = 0;
47043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47044 wxBitmap *result = 0 ;
47045 void *argp1 = 0 ;
47046 int res1 = 0 ;
47047 PyObject *swig_obj[1] ;
47048
47049 if (!args) SWIG_fail;
47050 swig_obj[0] = args;
47051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47052 if (!SWIG_IsOK(res1)) {
47053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47054 }
47055 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47056 {
47057 PyThreadState* __tstate = wxPyBeginAllowThreads();
47058 {
47059 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47060 result = (wxBitmap *) &_result_ref;
47061 }
47062 wxPyEndAllowThreads(__tstate);
47063 if (PyErr_Occurred()) SWIG_fail;
47064 }
47065 {
47066 wxBitmap* resultptr = new wxBitmap(*result);
47067 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47068 }
47069 return resultobj;
47070 fail:
47071 return NULL;
47072 }
47073
47074
47075 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47076 PyObject *resultobj = 0;
47077 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47078 int arg2 ;
47079 void *argp1 = 0 ;
47080 int res1 = 0 ;
47081 int val2 ;
47082 int ecode2 = 0 ;
47083 PyObject * obj0 = 0 ;
47084 PyObject * obj1 = 0 ;
47085 char * kwnames[] = {
47086 (char *) "self",(char *) "nWidth", NULL
47087 };
47088
47089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47091 if (!SWIG_IsOK(res1)) {
47092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47093 }
47094 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47095 ecode2 = SWIG_AsVal_int(obj1, &val2);
47096 if (!SWIG_IsOK(ecode2)) {
47097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47098 }
47099 arg2 = static_cast< int >(val2);
47100 {
47101 PyThreadState* __tstate = wxPyBeginAllowThreads();
47102 (arg1)->SetMarginWidth(arg2);
47103 wxPyEndAllowThreads(__tstate);
47104 if (PyErr_Occurred()) SWIG_fail;
47105 }
47106 resultobj = SWIG_Py_Void();
47107 return resultobj;
47108 fail:
47109 return NULL;
47110 }
47111
47112
47113 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47114 PyObject *resultobj = 0;
47115 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47116 int result;
47117 void *argp1 = 0 ;
47118 int res1 = 0 ;
47119 PyObject *swig_obj[1] ;
47120
47121 if (!args) SWIG_fail;
47122 swig_obj[0] = args;
47123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47124 if (!SWIG_IsOK(res1)) {
47125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47126 }
47127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47128 {
47129 PyThreadState* __tstate = wxPyBeginAllowThreads();
47130 result = (int)(arg1)->GetMarginWidth();
47131 wxPyEndAllowThreads(__tstate);
47132 if (PyErr_Occurred()) SWIG_fail;
47133 }
47134 resultobj = SWIG_From_int(static_cast< int >(result));
47135 return resultobj;
47136 fail:
47137 return NULL;
47138 }
47139
47140
47141 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47142 PyObject *resultobj = 0;
47143 int result;
47144
47145 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47146 {
47147 PyThreadState* __tstate = wxPyBeginAllowThreads();
47148 result = (int)wxMenuItem::GetDefaultMarginWidth();
47149 wxPyEndAllowThreads(__tstate);
47150 if (PyErr_Occurred()) SWIG_fail;
47151 }
47152 resultobj = SWIG_From_int(static_cast< int >(result));
47153 return resultobj;
47154 fail:
47155 return NULL;
47156 }
47157
47158
47159 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47160 PyObject *resultobj = 0;
47161 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47162 bool result;
47163 void *argp1 = 0 ;
47164 int res1 = 0 ;
47165 PyObject *swig_obj[1] ;
47166
47167 if (!args) SWIG_fail;
47168 swig_obj[0] = args;
47169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47170 if (!SWIG_IsOK(res1)) {
47171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47172 }
47173 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47174 {
47175 PyThreadState* __tstate = wxPyBeginAllowThreads();
47176 result = (bool)(arg1)->IsOwnerDrawn();
47177 wxPyEndAllowThreads(__tstate);
47178 if (PyErr_Occurred()) SWIG_fail;
47179 }
47180 {
47181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47182 }
47183 return resultobj;
47184 fail:
47185 return NULL;
47186 }
47187
47188
47189 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47190 PyObject *resultobj = 0;
47191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47192 bool arg2 = (bool) true ;
47193 void *argp1 = 0 ;
47194 int res1 = 0 ;
47195 bool val2 ;
47196 int ecode2 = 0 ;
47197 PyObject * obj0 = 0 ;
47198 PyObject * obj1 = 0 ;
47199 char * kwnames[] = {
47200 (char *) "self",(char *) "ownerDrawn", NULL
47201 };
47202
47203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47205 if (!SWIG_IsOK(res1)) {
47206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47207 }
47208 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47209 if (obj1) {
47210 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47211 if (!SWIG_IsOK(ecode2)) {
47212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47213 }
47214 arg2 = static_cast< bool >(val2);
47215 }
47216 {
47217 PyThreadState* __tstate = wxPyBeginAllowThreads();
47218 (arg1)->SetOwnerDrawn(arg2);
47219 wxPyEndAllowThreads(__tstate);
47220 if (PyErr_Occurred()) SWIG_fail;
47221 }
47222 resultobj = SWIG_Py_Void();
47223 return resultobj;
47224 fail:
47225 return NULL;
47226 }
47227
47228
47229 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47230 PyObject *resultobj = 0;
47231 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47232 void *argp1 = 0 ;
47233 int res1 = 0 ;
47234 PyObject *swig_obj[1] ;
47235
47236 if (!args) SWIG_fail;
47237 swig_obj[0] = args;
47238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47241 }
47242 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47243 {
47244 PyThreadState* __tstate = wxPyBeginAllowThreads();
47245 (arg1)->ResetOwnerDrawn();
47246 wxPyEndAllowThreads(__tstate);
47247 if (PyErr_Occurred()) SWIG_fail;
47248 }
47249 resultobj = SWIG_Py_Void();
47250 return resultobj;
47251 fail:
47252 return NULL;
47253 }
47254
47255
47256 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47257 PyObject *obj;
47258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47259 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47260 return SWIG_Py_Void();
47261 }
47262
47263 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47264 return SWIG_Python_InitShadowInstance(args);
47265 }
47266
47267 SWIGINTERN int ControlNameStr_set(PyObject *) {
47268 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47269 return 1;
47270 }
47271
47272
47273 SWIGINTERN PyObject *ControlNameStr_get(void) {
47274 PyObject *pyobj = 0;
47275
47276 {
47277 #if wxUSE_UNICODE
47278 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47279 #else
47280 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47281 #endif
47282 }
47283 return pyobj;
47284 }
47285
47286
47287 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47288 PyObject *resultobj = 0;
47289 wxWindow *arg1 = (wxWindow *) 0 ;
47290 int arg2 = (int) -1 ;
47291 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47292 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47293 wxSize const &arg4_defvalue = wxDefaultSize ;
47294 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47295 long arg5 = (long) 0 ;
47296 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47297 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47298 wxString const &arg7_defvalue = wxPyControlNameStr ;
47299 wxString *arg7 = (wxString *) &arg7_defvalue ;
47300 wxControl *result = 0 ;
47301 void *argp1 = 0 ;
47302 int res1 = 0 ;
47303 int val2 ;
47304 int ecode2 = 0 ;
47305 wxPoint temp3 ;
47306 wxSize temp4 ;
47307 long val5 ;
47308 int ecode5 = 0 ;
47309 void *argp6 = 0 ;
47310 int res6 = 0 ;
47311 bool temp7 = false ;
47312 PyObject * obj0 = 0 ;
47313 PyObject * obj1 = 0 ;
47314 PyObject * obj2 = 0 ;
47315 PyObject * obj3 = 0 ;
47316 PyObject * obj4 = 0 ;
47317 PyObject * obj5 = 0 ;
47318 PyObject * obj6 = 0 ;
47319 char * kwnames[] = {
47320 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47321 };
47322
47323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47325 if (!SWIG_IsOK(res1)) {
47326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47327 }
47328 arg1 = reinterpret_cast< wxWindow * >(argp1);
47329 if (obj1) {
47330 ecode2 = SWIG_AsVal_int(obj1, &val2);
47331 if (!SWIG_IsOK(ecode2)) {
47332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47333 }
47334 arg2 = static_cast< int >(val2);
47335 }
47336 if (obj2) {
47337 {
47338 arg3 = &temp3;
47339 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47340 }
47341 }
47342 if (obj3) {
47343 {
47344 arg4 = &temp4;
47345 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47346 }
47347 }
47348 if (obj4) {
47349 ecode5 = SWIG_AsVal_long(obj4, &val5);
47350 if (!SWIG_IsOK(ecode5)) {
47351 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47352 }
47353 arg5 = static_cast< long >(val5);
47354 }
47355 if (obj5) {
47356 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47357 if (!SWIG_IsOK(res6)) {
47358 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47359 }
47360 if (!argp6) {
47361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47362 }
47363 arg6 = reinterpret_cast< wxValidator * >(argp6);
47364 }
47365 if (obj6) {
47366 {
47367 arg7 = wxString_in_helper(obj6);
47368 if (arg7 == NULL) SWIG_fail;
47369 temp7 = true;
47370 }
47371 }
47372 {
47373 if (!wxPyCheckForApp()) SWIG_fail;
47374 PyThreadState* __tstate = wxPyBeginAllowThreads();
47375 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47376 wxPyEndAllowThreads(__tstate);
47377 if (PyErr_Occurred()) SWIG_fail;
47378 }
47379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47380 {
47381 if (temp7)
47382 delete arg7;
47383 }
47384 return resultobj;
47385 fail:
47386 {
47387 if (temp7)
47388 delete arg7;
47389 }
47390 return NULL;
47391 }
47392
47393
47394 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47395 PyObject *resultobj = 0;
47396 wxControl *result = 0 ;
47397
47398 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47399 {
47400 if (!wxPyCheckForApp()) SWIG_fail;
47401 PyThreadState* __tstate = wxPyBeginAllowThreads();
47402 result = (wxControl *)new wxControl();
47403 wxPyEndAllowThreads(__tstate);
47404 if (PyErr_Occurred()) SWIG_fail;
47405 }
47406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47407 return resultobj;
47408 fail:
47409 return NULL;
47410 }
47411
47412
47413 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47414 PyObject *resultobj = 0;
47415 wxControl *arg1 = (wxControl *) 0 ;
47416 wxWindow *arg2 = (wxWindow *) 0 ;
47417 int arg3 = (int) -1 ;
47418 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47419 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47420 wxSize const &arg5_defvalue = wxDefaultSize ;
47421 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47422 long arg6 = (long) 0 ;
47423 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47424 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47425 wxString const &arg8_defvalue = wxPyControlNameStr ;
47426 wxString *arg8 = (wxString *) &arg8_defvalue ;
47427 bool result;
47428 void *argp1 = 0 ;
47429 int res1 = 0 ;
47430 void *argp2 = 0 ;
47431 int res2 = 0 ;
47432 int val3 ;
47433 int ecode3 = 0 ;
47434 wxPoint temp4 ;
47435 wxSize temp5 ;
47436 long val6 ;
47437 int ecode6 = 0 ;
47438 void *argp7 = 0 ;
47439 int res7 = 0 ;
47440 bool temp8 = false ;
47441 PyObject * obj0 = 0 ;
47442 PyObject * obj1 = 0 ;
47443 PyObject * obj2 = 0 ;
47444 PyObject * obj3 = 0 ;
47445 PyObject * obj4 = 0 ;
47446 PyObject * obj5 = 0 ;
47447 PyObject * obj6 = 0 ;
47448 PyObject * obj7 = 0 ;
47449 char * kwnames[] = {
47450 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47451 };
47452
47453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47455 if (!SWIG_IsOK(res1)) {
47456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47457 }
47458 arg1 = reinterpret_cast< wxControl * >(argp1);
47459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47460 if (!SWIG_IsOK(res2)) {
47461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47462 }
47463 arg2 = reinterpret_cast< wxWindow * >(argp2);
47464 if (obj2) {
47465 ecode3 = SWIG_AsVal_int(obj2, &val3);
47466 if (!SWIG_IsOK(ecode3)) {
47467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47468 }
47469 arg3 = static_cast< int >(val3);
47470 }
47471 if (obj3) {
47472 {
47473 arg4 = &temp4;
47474 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47475 }
47476 }
47477 if (obj4) {
47478 {
47479 arg5 = &temp5;
47480 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47481 }
47482 }
47483 if (obj5) {
47484 ecode6 = SWIG_AsVal_long(obj5, &val6);
47485 if (!SWIG_IsOK(ecode6)) {
47486 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47487 }
47488 arg6 = static_cast< long >(val6);
47489 }
47490 if (obj6) {
47491 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47492 if (!SWIG_IsOK(res7)) {
47493 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47494 }
47495 if (!argp7) {
47496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47497 }
47498 arg7 = reinterpret_cast< wxValidator * >(argp7);
47499 }
47500 if (obj7) {
47501 {
47502 arg8 = wxString_in_helper(obj7);
47503 if (arg8 == NULL) SWIG_fail;
47504 temp8 = true;
47505 }
47506 }
47507 {
47508 PyThreadState* __tstate = wxPyBeginAllowThreads();
47509 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47510 wxPyEndAllowThreads(__tstate);
47511 if (PyErr_Occurred()) SWIG_fail;
47512 }
47513 {
47514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47515 }
47516 {
47517 if (temp8)
47518 delete arg8;
47519 }
47520 return resultobj;
47521 fail:
47522 {
47523 if (temp8)
47524 delete arg8;
47525 }
47526 return NULL;
47527 }
47528
47529
47530 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47531 PyObject *resultobj = 0;
47532 wxControl *arg1 = (wxControl *) 0 ;
47533 int result;
47534 void *argp1 = 0 ;
47535 int res1 = 0 ;
47536 PyObject *swig_obj[1] ;
47537
47538 if (!args) SWIG_fail;
47539 swig_obj[0] = args;
47540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47541 if (!SWIG_IsOK(res1)) {
47542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47543 }
47544 arg1 = reinterpret_cast< wxControl * >(argp1);
47545 {
47546 PyThreadState* __tstate = wxPyBeginAllowThreads();
47547 result = (int)((wxControl const *)arg1)->GetAlignment();
47548 wxPyEndAllowThreads(__tstate);
47549 if (PyErr_Occurred()) SWIG_fail;
47550 }
47551 resultobj = SWIG_From_int(static_cast< int >(result));
47552 return resultobj;
47553 fail:
47554 return NULL;
47555 }
47556
47557
47558 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47559 PyObject *resultobj = 0;
47560 wxControl *arg1 = (wxControl *) 0 ;
47561 wxString result;
47562 void *argp1 = 0 ;
47563 int res1 = 0 ;
47564 PyObject *swig_obj[1] ;
47565
47566 if (!args) SWIG_fail;
47567 swig_obj[0] = args;
47568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47569 if (!SWIG_IsOK(res1)) {
47570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47571 }
47572 arg1 = reinterpret_cast< wxControl * >(argp1);
47573 {
47574 PyThreadState* __tstate = wxPyBeginAllowThreads();
47575 result = ((wxControl const *)arg1)->GetLabelText();
47576 wxPyEndAllowThreads(__tstate);
47577 if (PyErr_Occurred()) SWIG_fail;
47578 }
47579 {
47580 #if wxUSE_UNICODE
47581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47582 #else
47583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47584 #endif
47585 }
47586 return resultobj;
47587 fail:
47588 return NULL;
47589 }
47590
47591
47592 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47593 PyObject *resultobj = 0;
47594 wxControl *arg1 = (wxControl *) 0 ;
47595 wxCommandEvent *arg2 = 0 ;
47596 void *argp1 = 0 ;
47597 int res1 = 0 ;
47598 void *argp2 = 0 ;
47599 int res2 = 0 ;
47600 PyObject * obj0 = 0 ;
47601 PyObject * obj1 = 0 ;
47602 char * kwnames[] = {
47603 (char *) "self",(char *) "event", NULL
47604 };
47605
47606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47608 if (!SWIG_IsOK(res1)) {
47609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47610 }
47611 arg1 = reinterpret_cast< wxControl * >(argp1);
47612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47613 if (!SWIG_IsOK(res2)) {
47614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47615 }
47616 if (!argp2) {
47617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47618 }
47619 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47620 {
47621 PyThreadState* __tstate = wxPyBeginAllowThreads();
47622 (arg1)->Command(*arg2);
47623 wxPyEndAllowThreads(__tstate);
47624 if (PyErr_Occurred()) SWIG_fail;
47625 }
47626 resultobj = SWIG_Py_Void();
47627 return resultobj;
47628 fail:
47629 return NULL;
47630 }
47631
47632
47633 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47634 PyObject *resultobj = 0;
47635 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47636 SwigValueWrapper<wxVisualAttributes > result;
47637 int val1 ;
47638 int ecode1 = 0 ;
47639 PyObject * obj0 = 0 ;
47640 char * kwnames[] = {
47641 (char *) "variant", NULL
47642 };
47643
47644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47645 if (obj0) {
47646 ecode1 = SWIG_AsVal_int(obj0, &val1);
47647 if (!SWIG_IsOK(ecode1)) {
47648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47649 }
47650 arg1 = static_cast< wxWindowVariant >(val1);
47651 }
47652 {
47653 if (!wxPyCheckForApp()) SWIG_fail;
47654 PyThreadState* __tstate = wxPyBeginAllowThreads();
47655 result = wxControl::GetClassDefaultAttributes(arg1);
47656 wxPyEndAllowThreads(__tstate);
47657 if (PyErr_Occurred()) SWIG_fail;
47658 }
47659 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47660 return resultobj;
47661 fail:
47662 return NULL;
47663 }
47664
47665
47666 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47667 PyObject *obj;
47668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47669 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47670 return SWIG_Py_Void();
47671 }
47672
47673 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47674 return SWIG_Python_InitShadowInstance(args);
47675 }
47676
47677 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47678 PyObject *resultobj = 0;
47679 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47680 wxString *arg2 = 0 ;
47681 PyObject *arg3 = (PyObject *) NULL ;
47682 int result;
47683 void *argp1 = 0 ;
47684 int res1 = 0 ;
47685 bool temp2 = false ;
47686 PyObject * obj0 = 0 ;
47687 PyObject * obj1 = 0 ;
47688 PyObject * obj2 = 0 ;
47689 char * kwnames[] = {
47690 (char *) "self",(char *) "item",(char *) "clientData", NULL
47691 };
47692
47693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47695 if (!SWIG_IsOK(res1)) {
47696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47697 }
47698 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47699 {
47700 arg2 = wxString_in_helper(obj1);
47701 if (arg2 == NULL) SWIG_fail;
47702 temp2 = true;
47703 }
47704 if (obj2) {
47705 arg3 = obj2;
47706 }
47707 {
47708 PyThreadState* __tstate = wxPyBeginAllowThreads();
47709 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47710 wxPyEndAllowThreads(__tstate);
47711 if (PyErr_Occurred()) SWIG_fail;
47712 }
47713 resultobj = SWIG_From_int(static_cast< int >(result));
47714 {
47715 if (temp2)
47716 delete arg2;
47717 }
47718 return resultobj;
47719 fail:
47720 {
47721 if (temp2)
47722 delete arg2;
47723 }
47724 return NULL;
47725 }
47726
47727
47728 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47729 PyObject *resultobj = 0;
47730 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47731 wxArrayString *arg2 = 0 ;
47732 void *argp1 = 0 ;
47733 int res1 = 0 ;
47734 bool temp2 = false ;
47735 PyObject * obj0 = 0 ;
47736 PyObject * obj1 = 0 ;
47737 char * kwnames[] = {
47738 (char *) "self",(char *) "strings", NULL
47739 };
47740
47741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47743 if (!SWIG_IsOK(res1)) {
47744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47745 }
47746 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47747 {
47748 if (! PySequence_Check(obj1)) {
47749 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47750 SWIG_fail;
47751 }
47752 arg2 = new wxArrayString;
47753 temp2 = true;
47754 int i, len=PySequence_Length(obj1);
47755 for (i=0; i<len; i++) {
47756 PyObject* item = PySequence_GetItem(obj1, i);
47757 wxString* s = wxString_in_helper(item);
47758 if (PyErr_Occurred()) SWIG_fail;
47759 arg2->Add(*s);
47760 delete s;
47761 Py_DECREF(item);
47762 }
47763 }
47764 {
47765 PyThreadState* __tstate = wxPyBeginAllowThreads();
47766 (arg1)->Append((wxArrayString const &)*arg2);
47767 wxPyEndAllowThreads(__tstate);
47768 if (PyErr_Occurred()) SWIG_fail;
47769 }
47770 resultobj = SWIG_Py_Void();
47771 {
47772 if (temp2) delete arg2;
47773 }
47774 return resultobj;
47775 fail:
47776 {
47777 if (temp2) delete arg2;
47778 }
47779 return NULL;
47780 }
47781
47782
47783 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47784 PyObject *resultobj = 0;
47785 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47786 wxString *arg2 = 0 ;
47787 int arg3 ;
47788 PyObject *arg4 = (PyObject *) NULL ;
47789 int result;
47790 void *argp1 = 0 ;
47791 int res1 = 0 ;
47792 bool temp2 = false ;
47793 int val3 ;
47794 int ecode3 = 0 ;
47795 PyObject * obj0 = 0 ;
47796 PyObject * obj1 = 0 ;
47797 PyObject * obj2 = 0 ;
47798 PyObject * obj3 = 0 ;
47799 char * kwnames[] = {
47800 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47801 };
47802
47803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47805 if (!SWIG_IsOK(res1)) {
47806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47807 }
47808 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47809 {
47810 arg2 = wxString_in_helper(obj1);
47811 if (arg2 == NULL) SWIG_fail;
47812 temp2 = true;
47813 }
47814 ecode3 = SWIG_AsVal_int(obj2, &val3);
47815 if (!SWIG_IsOK(ecode3)) {
47816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47817 }
47818 arg3 = static_cast< int >(val3);
47819 if (obj3) {
47820 arg4 = obj3;
47821 }
47822 {
47823 PyThreadState* __tstate = wxPyBeginAllowThreads();
47824 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47825 wxPyEndAllowThreads(__tstate);
47826 if (PyErr_Occurred()) SWIG_fail;
47827 }
47828 resultobj = SWIG_From_int(static_cast< int >(result));
47829 {
47830 if (temp2)
47831 delete arg2;
47832 }
47833 return resultobj;
47834 fail:
47835 {
47836 if (temp2)
47837 delete arg2;
47838 }
47839 return NULL;
47840 }
47841
47842
47843 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47844 PyObject *resultobj = 0;
47845 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47846 void *argp1 = 0 ;
47847 int res1 = 0 ;
47848 PyObject *swig_obj[1] ;
47849
47850 if (!args) SWIG_fail;
47851 swig_obj[0] = args;
47852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47853 if (!SWIG_IsOK(res1)) {
47854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47855 }
47856 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47857 {
47858 PyThreadState* __tstate = wxPyBeginAllowThreads();
47859 (arg1)->Clear();
47860 wxPyEndAllowThreads(__tstate);
47861 if (PyErr_Occurred()) SWIG_fail;
47862 }
47863 resultobj = SWIG_Py_Void();
47864 return resultobj;
47865 fail:
47866 return NULL;
47867 }
47868
47869
47870 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47871 PyObject *resultobj = 0;
47872 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47873 int arg2 ;
47874 void *argp1 = 0 ;
47875 int res1 = 0 ;
47876 int val2 ;
47877 int ecode2 = 0 ;
47878 PyObject * obj0 = 0 ;
47879 PyObject * obj1 = 0 ;
47880 char * kwnames[] = {
47881 (char *) "self",(char *) "n", NULL
47882 };
47883
47884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47886 if (!SWIG_IsOK(res1)) {
47887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47888 }
47889 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47890 ecode2 = SWIG_AsVal_int(obj1, &val2);
47891 if (!SWIG_IsOK(ecode2)) {
47892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
47893 }
47894 arg2 = static_cast< int >(val2);
47895 {
47896 PyThreadState* __tstate = wxPyBeginAllowThreads();
47897 (arg1)->Delete(arg2);
47898 wxPyEndAllowThreads(__tstate);
47899 if (PyErr_Occurred()) SWIG_fail;
47900 }
47901 resultobj = SWIG_Py_Void();
47902 return resultobj;
47903 fail:
47904 return NULL;
47905 }
47906
47907
47908 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47909 PyObject *resultobj = 0;
47910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47911 int arg2 ;
47912 PyObject *result = 0 ;
47913 void *argp1 = 0 ;
47914 int res1 = 0 ;
47915 int val2 ;
47916 int ecode2 = 0 ;
47917 PyObject * obj0 = 0 ;
47918 PyObject * obj1 = 0 ;
47919 char * kwnames[] = {
47920 (char *) "self",(char *) "n", NULL
47921 };
47922
47923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47925 if (!SWIG_IsOK(res1)) {
47926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47927 }
47928 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47929 ecode2 = SWIG_AsVal_int(obj1, &val2);
47930 if (!SWIG_IsOK(ecode2)) {
47931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
47932 }
47933 arg2 = static_cast< int >(val2);
47934 {
47935 PyThreadState* __tstate = wxPyBeginAllowThreads();
47936 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47937 wxPyEndAllowThreads(__tstate);
47938 if (PyErr_Occurred()) SWIG_fail;
47939 }
47940 resultobj = result;
47941 return resultobj;
47942 fail:
47943 return NULL;
47944 }
47945
47946
47947 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47948 PyObject *resultobj = 0;
47949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47950 int arg2 ;
47951 PyObject *arg3 = (PyObject *) 0 ;
47952 void *argp1 = 0 ;
47953 int res1 = 0 ;
47954 int val2 ;
47955 int ecode2 = 0 ;
47956 PyObject * obj0 = 0 ;
47957 PyObject * obj1 = 0 ;
47958 PyObject * obj2 = 0 ;
47959 char * kwnames[] = {
47960 (char *) "self",(char *) "n",(char *) "clientData", NULL
47961 };
47962
47963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47965 if (!SWIG_IsOK(res1)) {
47966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47967 }
47968 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47969 ecode2 = SWIG_AsVal_int(obj1, &val2);
47970 if (!SWIG_IsOK(ecode2)) {
47971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
47972 }
47973 arg2 = static_cast< int >(val2);
47974 arg3 = obj2;
47975 {
47976 PyThreadState* __tstate = wxPyBeginAllowThreads();
47977 wxItemContainer_SetClientData(arg1,arg2,arg3);
47978 wxPyEndAllowThreads(__tstate);
47979 if (PyErr_Occurred()) SWIG_fail;
47980 }
47981 resultobj = SWIG_Py_Void();
47982 return resultobj;
47983 fail:
47984 return NULL;
47985 }
47986
47987
47988 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47989 PyObject *resultobj = 0;
47990 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47991 int result;
47992 void *argp1 = 0 ;
47993 int res1 = 0 ;
47994 PyObject *swig_obj[1] ;
47995
47996 if (!args) SWIG_fail;
47997 swig_obj[0] = args;
47998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47999 if (!SWIG_IsOK(res1)) {
48000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48001 }
48002 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48003 {
48004 PyThreadState* __tstate = wxPyBeginAllowThreads();
48005 result = (int)((wxItemContainer const *)arg1)->GetCount();
48006 wxPyEndAllowThreads(__tstate);
48007 if (PyErr_Occurred()) SWIG_fail;
48008 }
48009 resultobj = SWIG_From_int(static_cast< int >(result));
48010 return resultobj;
48011 fail:
48012 return NULL;
48013 }
48014
48015
48016 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48017 PyObject *resultobj = 0;
48018 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48019 bool result;
48020 void *argp1 = 0 ;
48021 int res1 = 0 ;
48022 PyObject *swig_obj[1] ;
48023
48024 if (!args) SWIG_fail;
48025 swig_obj[0] = args;
48026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48027 if (!SWIG_IsOK(res1)) {
48028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48029 }
48030 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48031 {
48032 PyThreadState* __tstate = wxPyBeginAllowThreads();
48033 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48034 wxPyEndAllowThreads(__tstate);
48035 if (PyErr_Occurred()) SWIG_fail;
48036 }
48037 {
48038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48039 }
48040 return resultobj;
48041 fail:
48042 return NULL;
48043 }
48044
48045
48046 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48047 PyObject *resultobj = 0;
48048 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48049 int arg2 ;
48050 wxString result;
48051 void *argp1 = 0 ;
48052 int res1 = 0 ;
48053 int val2 ;
48054 int ecode2 = 0 ;
48055 PyObject * obj0 = 0 ;
48056 PyObject * obj1 = 0 ;
48057 char * kwnames[] = {
48058 (char *) "self",(char *) "n", NULL
48059 };
48060
48061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48063 if (!SWIG_IsOK(res1)) {
48064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48065 }
48066 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48067 ecode2 = SWIG_AsVal_int(obj1, &val2);
48068 if (!SWIG_IsOK(ecode2)) {
48069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48070 }
48071 arg2 = static_cast< int >(val2);
48072 {
48073 PyThreadState* __tstate = wxPyBeginAllowThreads();
48074 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48075 wxPyEndAllowThreads(__tstate);
48076 if (PyErr_Occurred()) SWIG_fail;
48077 }
48078 {
48079 #if wxUSE_UNICODE
48080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48081 #else
48082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48083 #endif
48084 }
48085 return resultobj;
48086 fail:
48087 return NULL;
48088 }
48089
48090
48091 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48092 PyObject *resultobj = 0;
48093 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48094 wxArrayString result;
48095 void *argp1 = 0 ;
48096 int res1 = 0 ;
48097 PyObject *swig_obj[1] ;
48098
48099 if (!args) SWIG_fail;
48100 swig_obj[0] = args;
48101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48102 if (!SWIG_IsOK(res1)) {
48103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48104 }
48105 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48106 {
48107 PyThreadState* __tstate = wxPyBeginAllowThreads();
48108 result = ((wxItemContainer const *)arg1)->GetStrings();
48109 wxPyEndAllowThreads(__tstate);
48110 if (PyErr_Occurred()) SWIG_fail;
48111 }
48112 {
48113 resultobj = wxArrayString2PyList_helper(result);
48114 }
48115 return resultobj;
48116 fail:
48117 return NULL;
48118 }
48119
48120
48121 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48122 PyObject *resultobj = 0;
48123 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48124 int arg2 ;
48125 wxString *arg3 = 0 ;
48126 void *argp1 = 0 ;
48127 int res1 = 0 ;
48128 int val2 ;
48129 int ecode2 = 0 ;
48130 bool temp3 = false ;
48131 PyObject * obj0 = 0 ;
48132 PyObject * obj1 = 0 ;
48133 PyObject * obj2 = 0 ;
48134 char * kwnames[] = {
48135 (char *) "self",(char *) "n",(char *) "s", NULL
48136 };
48137
48138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48140 if (!SWIG_IsOK(res1)) {
48141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48142 }
48143 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48144 ecode2 = SWIG_AsVal_int(obj1, &val2);
48145 if (!SWIG_IsOK(ecode2)) {
48146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48147 }
48148 arg2 = static_cast< int >(val2);
48149 {
48150 arg3 = wxString_in_helper(obj2);
48151 if (arg3 == NULL) SWIG_fail;
48152 temp3 = true;
48153 }
48154 {
48155 PyThreadState* __tstate = wxPyBeginAllowThreads();
48156 (arg1)->SetString(arg2,(wxString const &)*arg3);
48157 wxPyEndAllowThreads(__tstate);
48158 if (PyErr_Occurred()) SWIG_fail;
48159 }
48160 resultobj = SWIG_Py_Void();
48161 {
48162 if (temp3)
48163 delete arg3;
48164 }
48165 return resultobj;
48166 fail:
48167 {
48168 if (temp3)
48169 delete arg3;
48170 }
48171 return NULL;
48172 }
48173
48174
48175 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48176 PyObject *resultobj = 0;
48177 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48178 wxString *arg2 = 0 ;
48179 int result;
48180 void *argp1 = 0 ;
48181 int res1 = 0 ;
48182 bool temp2 = false ;
48183 PyObject * obj0 = 0 ;
48184 PyObject * obj1 = 0 ;
48185 char * kwnames[] = {
48186 (char *) "self",(char *) "s", NULL
48187 };
48188
48189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48191 if (!SWIG_IsOK(res1)) {
48192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48193 }
48194 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48195 {
48196 arg2 = wxString_in_helper(obj1);
48197 if (arg2 == NULL) SWIG_fail;
48198 temp2 = true;
48199 }
48200 {
48201 PyThreadState* __tstate = wxPyBeginAllowThreads();
48202 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48203 wxPyEndAllowThreads(__tstate);
48204 if (PyErr_Occurred()) SWIG_fail;
48205 }
48206 resultobj = SWIG_From_int(static_cast< int >(result));
48207 {
48208 if (temp2)
48209 delete arg2;
48210 }
48211 return resultobj;
48212 fail:
48213 {
48214 if (temp2)
48215 delete arg2;
48216 }
48217 return NULL;
48218 }
48219
48220
48221 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48222 PyObject *resultobj = 0;
48223 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48224 int arg2 ;
48225 void *argp1 = 0 ;
48226 int res1 = 0 ;
48227 int val2 ;
48228 int ecode2 = 0 ;
48229 PyObject * obj0 = 0 ;
48230 PyObject * obj1 = 0 ;
48231 char * kwnames[] = {
48232 (char *) "self",(char *) "n", NULL
48233 };
48234
48235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48237 if (!SWIG_IsOK(res1)) {
48238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48239 }
48240 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48241 ecode2 = SWIG_AsVal_int(obj1, &val2);
48242 if (!SWIG_IsOK(ecode2)) {
48243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48244 }
48245 arg2 = static_cast< int >(val2);
48246 {
48247 PyThreadState* __tstate = wxPyBeginAllowThreads();
48248 (arg1)->SetSelection(arg2);
48249 wxPyEndAllowThreads(__tstate);
48250 if (PyErr_Occurred()) SWIG_fail;
48251 }
48252 resultobj = SWIG_Py_Void();
48253 return resultobj;
48254 fail:
48255 return NULL;
48256 }
48257
48258
48259 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48260 PyObject *resultobj = 0;
48261 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48262 int result;
48263 void *argp1 = 0 ;
48264 int res1 = 0 ;
48265 PyObject *swig_obj[1] ;
48266
48267 if (!args) SWIG_fail;
48268 swig_obj[0] = args;
48269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48270 if (!SWIG_IsOK(res1)) {
48271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48272 }
48273 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48274 {
48275 PyThreadState* __tstate = wxPyBeginAllowThreads();
48276 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48277 wxPyEndAllowThreads(__tstate);
48278 if (PyErr_Occurred()) SWIG_fail;
48279 }
48280 resultobj = SWIG_From_int(static_cast< int >(result));
48281 return resultobj;
48282 fail:
48283 return NULL;
48284 }
48285
48286
48287 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48288 PyObject *resultobj = 0;
48289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48290 wxString *arg2 = 0 ;
48291 bool result;
48292 void *argp1 = 0 ;
48293 int res1 = 0 ;
48294 bool temp2 = false ;
48295 PyObject * obj0 = 0 ;
48296 PyObject * obj1 = 0 ;
48297 char * kwnames[] = {
48298 (char *) "self",(char *) "s", NULL
48299 };
48300
48301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48303 if (!SWIG_IsOK(res1)) {
48304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48305 }
48306 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48307 {
48308 arg2 = wxString_in_helper(obj1);
48309 if (arg2 == NULL) SWIG_fail;
48310 temp2 = true;
48311 }
48312 {
48313 PyThreadState* __tstate = wxPyBeginAllowThreads();
48314 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48315 wxPyEndAllowThreads(__tstate);
48316 if (PyErr_Occurred()) SWIG_fail;
48317 }
48318 {
48319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48320 }
48321 {
48322 if (temp2)
48323 delete arg2;
48324 }
48325 return resultobj;
48326 fail:
48327 {
48328 if (temp2)
48329 delete arg2;
48330 }
48331 return NULL;
48332 }
48333
48334
48335 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48336 PyObject *resultobj = 0;
48337 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48338 wxString result;
48339 void *argp1 = 0 ;
48340 int res1 = 0 ;
48341 PyObject *swig_obj[1] ;
48342
48343 if (!args) SWIG_fail;
48344 swig_obj[0] = args;
48345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48346 if (!SWIG_IsOK(res1)) {
48347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48348 }
48349 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48350 {
48351 PyThreadState* __tstate = wxPyBeginAllowThreads();
48352 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48353 wxPyEndAllowThreads(__tstate);
48354 if (PyErr_Occurred()) SWIG_fail;
48355 }
48356 {
48357 #if wxUSE_UNICODE
48358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48359 #else
48360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48361 #endif
48362 }
48363 return resultobj;
48364 fail:
48365 return NULL;
48366 }
48367
48368
48369 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48370 PyObject *resultobj = 0;
48371 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48372 int arg2 ;
48373 void *argp1 = 0 ;
48374 int res1 = 0 ;
48375 int val2 ;
48376 int ecode2 = 0 ;
48377 PyObject * obj0 = 0 ;
48378 PyObject * obj1 = 0 ;
48379 char * kwnames[] = {
48380 (char *) "self",(char *) "n", NULL
48381 };
48382
48383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48385 if (!SWIG_IsOK(res1)) {
48386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48387 }
48388 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48389 ecode2 = SWIG_AsVal_int(obj1, &val2);
48390 if (!SWIG_IsOK(ecode2)) {
48391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48392 }
48393 arg2 = static_cast< int >(val2);
48394 {
48395 PyThreadState* __tstate = wxPyBeginAllowThreads();
48396 (arg1)->Select(arg2);
48397 wxPyEndAllowThreads(__tstate);
48398 if (PyErr_Occurred()) SWIG_fail;
48399 }
48400 resultobj = SWIG_Py_Void();
48401 return resultobj;
48402 fail:
48403 return NULL;
48404 }
48405
48406
48407 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48408 PyObject *obj;
48409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48410 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48411 return SWIG_Py_Void();
48412 }
48413
48414 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48415 PyObject *obj;
48416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48417 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48418 return SWIG_Py_Void();
48419 }
48420
48421 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48422 PyObject *resultobj = 0;
48423 wxSizerItem *result = 0 ;
48424
48425 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48426 {
48427 PyThreadState* __tstate = wxPyBeginAllowThreads();
48428 result = (wxSizerItem *)new wxSizerItem();
48429 wxPyEndAllowThreads(__tstate);
48430 if (PyErr_Occurred()) SWIG_fail;
48431 }
48432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48433 return resultobj;
48434 fail:
48435 return NULL;
48436 }
48437
48438
48439 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48440 PyObject *resultobj = 0;
48441 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48442 void *argp1 = 0 ;
48443 int res1 = 0 ;
48444 PyObject *swig_obj[1] ;
48445
48446 if (!args) SWIG_fail;
48447 swig_obj[0] = args;
48448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48449 if (!SWIG_IsOK(res1)) {
48450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48451 }
48452 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48453 {
48454 PyThreadState* __tstate = wxPyBeginAllowThreads();
48455 delete arg1;
48456
48457 wxPyEndAllowThreads(__tstate);
48458 if (PyErr_Occurred()) SWIG_fail;
48459 }
48460 resultobj = SWIG_Py_Void();
48461 return resultobj;
48462 fail:
48463 return NULL;
48464 }
48465
48466
48467 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48468 PyObject *resultobj = 0;
48469 wxWindow *arg1 = (wxWindow *) 0 ;
48470 int arg2 ;
48471 int arg3 ;
48472 int arg4 ;
48473 PyObject *arg5 = (PyObject *) NULL ;
48474 wxSizerItem *result = 0 ;
48475 void *argp1 = 0 ;
48476 int res1 = 0 ;
48477 int val2 ;
48478 int ecode2 = 0 ;
48479 int val3 ;
48480 int ecode3 = 0 ;
48481 int val4 ;
48482 int ecode4 = 0 ;
48483 PyObject * obj0 = 0 ;
48484 PyObject * obj1 = 0 ;
48485 PyObject * obj2 = 0 ;
48486 PyObject * obj3 = 0 ;
48487 PyObject * obj4 = 0 ;
48488 char * kwnames[] = {
48489 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48490 };
48491
48492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48494 if (!SWIG_IsOK(res1)) {
48495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48496 }
48497 arg1 = reinterpret_cast< wxWindow * >(argp1);
48498 ecode2 = SWIG_AsVal_int(obj1, &val2);
48499 if (!SWIG_IsOK(ecode2)) {
48500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48501 }
48502 arg2 = static_cast< int >(val2);
48503 ecode3 = SWIG_AsVal_int(obj2, &val3);
48504 if (!SWIG_IsOK(ecode3)) {
48505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48506 }
48507 arg3 = static_cast< int >(val3);
48508 ecode4 = SWIG_AsVal_int(obj3, &val4);
48509 if (!SWIG_IsOK(ecode4)) {
48510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48511 }
48512 arg4 = static_cast< int >(val4);
48513 if (obj4) {
48514 arg5 = obj4;
48515 }
48516 {
48517 PyThreadState* __tstate = wxPyBeginAllowThreads();
48518 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48519 wxPyEndAllowThreads(__tstate);
48520 if (PyErr_Occurred()) SWIG_fail;
48521 }
48522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48523 return resultobj;
48524 fail:
48525 return NULL;
48526 }
48527
48528
48529 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48530 PyObject *resultobj = 0;
48531 int arg1 ;
48532 int arg2 ;
48533 int arg3 ;
48534 int arg4 ;
48535 int arg5 ;
48536 PyObject *arg6 = (PyObject *) NULL ;
48537 wxSizerItem *result = 0 ;
48538 int val1 ;
48539 int ecode1 = 0 ;
48540 int val2 ;
48541 int ecode2 = 0 ;
48542 int val3 ;
48543 int ecode3 = 0 ;
48544 int val4 ;
48545 int ecode4 = 0 ;
48546 int val5 ;
48547 int ecode5 = 0 ;
48548 PyObject * obj0 = 0 ;
48549 PyObject * obj1 = 0 ;
48550 PyObject * obj2 = 0 ;
48551 PyObject * obj3 = 0 ;
48552 PyObject * obj4 = 0 ;
48553 PyObject * obj5 = 0 ;
48554 char * kwnames[] = {
48555 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48556 };
48557
48558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48559 ecode1 = SWIG_AsVal_int(obj0, &val1);
48560 if (!SWIG_IsOK(ecode1)) {
48561 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48562 }
48563 arg1 = static_cast< int >(val1);
48564 ecode2 = SWIG_AsVal_int(obj1, &val2);
48565 if (!SWIG_IsOK(ecode2)) {
48566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48567 }
48568 arg2 = static_cast< int >(val2);
48569 ecode3 = SWIG_AsVal_int(obj2, &val3);
48570 if (!SWIG_IsOK(ecode3)) {
48571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48572 }
48573 arg3 = static_cast< int >(val3);
48574 ecode4 = SWIG_AsVal_int(obj3, &val4);
48575 if (!SWIG_IsOK(ecode4)) {
48576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48577 }
48578 arg4 = static_cast< int >(val4);
48579 ecode5 = SWIG_AsVal_int(obj4, &val5);
48580 if (!SWIG_IsOK(ecode5)) {
48581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48582 }
48583 arg5 = static_cast< int >(val5);
48584 if (obj5) {
48585 arg6 = obj5;
48586 }
48587 {
48588 PyThreadState* __tstate = wxPyBeginAllowThreads();
48589 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48590 wxPyEndAllowThreads(__tstate);
48591 if (PyErr_Occurred()) SWIG_fail;
48592 }
48593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48594 return resultobj;
48595 fail:
48596 return NULL;
48597 }
48598
48599
48600 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48601 PyObject *resultobj = 0;
48602 wxSizer *arg1 = (wxSizer *) 0 ;
48603 int arg2 ;
48604 int arg3 ;
48605 int arg4 ;
48606 PyObject *arg5 = (PyObject *) NULL ;
48607 wxSizerItem *result = 0 ;
48608 int res1 = 0 ;
48609 int val2 ;
48610 int ecode2 = 0 ;
48611 int val3 ;
48612 int ecode3 = 0 ;
48613 int val4 ;
48614 int ecode4 = 0 ;
48615 PyObject * obj0 = 0 ;
48616 PyObject * obj1 = 0 ;
48617 PyObject * obj2 = 0 ;
48618 PyObject * obj3 = 0 ;
48619 PyObject * obj4 = 0 ;
48620 char * kwnames[] = {
48621 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48622 };
48623
48624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48625 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48626 if (!SWIG_IsOK(res1)) {
48627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48628 }
48629 ecode2 = SWIG_AsVal_int(obj1, &val2);
48630 if (!SWIG_IsOK(ecode2)) {
48631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48632 }
48633 arg2 = static_cast< int >(val2);
48634 ecode3 = SWIG_AsVal_int(obj2, &val3);
48635 if (!SWIG_IsOK(ecode3)) {
48636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48637 }
48638 arg3 = static_cast< int >(val3);
48639 ecode4 = SWIG_AsVal_int(obj3, &val4);
48640 if (!SWIG_IsOK(ecode4)) {
48641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48642 }
48643 arg4 = static_cast< int >(val4);
48644 if (obj4) {
48645 arg5 = obj4;
48646 }
48647 {
48648 PyThreadState* __tstate = wxPyBeginAllowThreads();
48649 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48650 wxPyEndAllowThreads(__tstate);
48651 if (PyErr_Occurred()) SWIG_fail;
48652 }
48653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48654 return resultobj;
48655 fail:
48656 return NULL;
48657 }
48658
48659
48660 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48661 PyObject *resultobj = 0;
48662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48663 void *argp1 = 0 ;
48664 int res1 = 0 ;
48665 PyObject *swig_obj[1] ;
48666
48667 if (!args) SWIG_fail;
48668 swig_obj[0] = args;
48669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48672 }
48673 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48674 {
48675 PyThreadState* __tstate = wxPyBeginAllowThreads();
48676 (arg1)->DeleteWindows();
48677 wxPyEndAllowThreads(__tstate);
48678 if (PyErr_Occurred()) SWIG_fail;
48679 }
48680 resultobj = SWIG_Py_Void();
48681 return resultobj;
48682 fail:
48683 return NULL;
48684 }
48685
48686
48687 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48688 PyObject *resultobj = 0;
48689 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48690 void *argp1 = 0 ;
48691 int res1 = 0 ;
48692 PyObject *swig_obj[1] ;
48693
48694 if (!args) SWIG_fail;
48695 swig_obj[0] = args;
48696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48697 if (!SWIG_IsOK(res1)) {
48698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48699 }
48700 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48701 {
48702 PyThreadState* __tstate = wxPyBeginAllowThreads();
48703 (arg1)->DetachSizer();
48704 wxPyEndAllowThreads(__tstate);
48705 if (PyErr_Occurred()) SWIG_fail;
48706 }
48707 resultobj = SWIG_Py_Void();
48708 return resultobj;
48709 fail:
48710 return NULL;
48711 }
48712
48713
48714 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48715 PyObject *resultobj = 0;
48716 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48717 wxSize result;
48718 void *argp1 = 0 ;
48719 int res1 = 0 ;
48720 PyObject *swig_obj[1] ;
48721
48722 if (!args) SWIG_fail;
48723 swig_obj[0] = args;
48724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48725 if (!SWIG_IsOK(res1)) {
48726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48727 }
48728 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48729 {
48730 PyThreadState* __tstate = wxPyBeginAllowThreads();
48731 result = (arg1)->GetSize();
48732 wxPyEndAllowThreads(__tstate);
48733 if (PyErr_Occurred()) SWIG_fail;
48734 }
48735 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48736 return resultobj;
48737 fail:
48738 return NULL;
48739 }
48740
48741
48742 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48743 PyObject *resultobj = 0;
48744 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48745 wxSize result;
48746 void *argp1 = 0 ;
48747 int res1 = 0 ;
48748 PyObject *swig_obj[1] ;
48749
48750 if (!args) SWIG_fail;
48751 swig_obj[0] = args;
48752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48753 if (!SWIG_IsOK(res1)) {
48754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48755 }
48756 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48757 {
48758 PyThreadState* __tstate = wxPyBeginAllowThreads();
48759 result = (arg1)->CalcMin();
48760 wxPyEndAllowThreads(__tstate);
48761 if (PyErr_Occurred()) SWIG_fail;
48762 }
48763 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48764 return resultobj;
48765 fail:
48766 return NULL;
48767 }
48768
48769
48770 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48771 PyObject *resultobj = 0;
48772 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48773 wxPoint *arg2 = 0 ;
48774 wxSize *arg3 = 0 ;
48775 void *argp1 = 0 ;
48776 int res1 = 0 ;
48777 wxPoint temp2 ;
48778 wxSize temp3 ;
48779 PyObject * obj0 = 0 ;
48780 PyObject * obj1 = 0 ;
48781 PyObject * obj2 = 0 ;
48782 char * kwnames[] = {
48783 (char *) "self",(char *) "pos",(char *) "size", NULL
48784 };
48785
48786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48788 if (!SWIG_IsOK(res1)) {
48789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48790 }
48791 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48792 {
48793 arg2 = &temp2;
48794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48795 }
48796 {
48797 arg3 = &temp3;
48798 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48799 }
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48803 wxPyEndAllowThreads(__tstate);
48804 if (PyErr_Occurred()) SWIG_fail;
48805 }
48806 resultobj = SWIG_Py_Void();
48807 return resultobj;
48808 fail:
48809 return NULL;
48810 }
48811
48812
48813 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48814 PyObject *resultobj = 0;
48815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48816 wxSize result;
48817 void *argp1 = 0 ;
48818 int res1 = 0 ;
48819 PyObject *swig_obj[1] ;
48820
48821 if (!args) SWIG_fail;
48822 swig_obj[0] = args;
48823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48824 if (!SWIG_IsOK(res1)) {
48825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48826 }
48827 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48828 {
48829 PyThreadState* __tstate = wxPyBeginAllowThreads();
48830 result = (arg1)->GetMinSize();
48831 wxPyEndAllowThreads(__tstate);
48832 if (PyErr_Occurred()) SWIG_fail;
48833 }
48834 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48835 return resultobj;
48836 fail:
48837 return NULL;
48838 }
48839
48840
48841 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48842 PyObject *resultobj = 0;
48843 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48844 wxSize result;
48845 void *argp1 = 0 ;
48846 int res1 = 0 ;
48847 PyObject *swig_obj[1] ;
48848
48849 if (!args) SWIG_fail;
48850 swig_obj[0] = args;
48851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48852 if (!SWIG_IsOK(res1)) {
48853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48854 }
48855 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48856 {
48857 PyThreadState* __tstate = wxPyBeginAllowThreads();
48858 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48859 wxPyEndAllowThreads(__tstate);
48860 if (PyErr_Occurred()) SWIG_fail;
48861 }
48862 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48863 return resultobj;
48864 fail:
48865 return NULL;
48866 }
48867
48868
48869 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48870 PyObject *resultobj = 0;
48871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48872 int arg2 ;
48873 int arg3 ;
48874 void *argp1 = 0 ;
48875 int res1 = 0 ;
48876 int val2 ;
48877 int ecode2 = 0 ;
48878 int val3 ;
48879 int ecode3 = 0 ;
48880 PyObject * obj0 = 0 ;
48881 PyObject * obj1 = 0 ;
48882 PyObject * obj2 = 0 ;
48883 char * kwnames[] = {
48884 (char *) "self",(char *) "x",(char *) "y", NULL
48885 };
48886
48887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48889 if (!SWIG_IsOK(res1)) {
48890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48891 }
48892 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48893 ecode2 = SWIG_AsVal_int(obj1, &val2);
48894 if (!SWIG_IsOK(ecode2)) {
48895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48896 }
48897 arg2 = static_cast< int >(val2);
48898 ecode3 = SWIG_AsVal_int(obj2, &val3);
48899 if (!SWIG_IsOK(ecode3)) {
48900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48901 }
48902 arg3 = static_cast< int >(val3);
48903 {
48904 PyThreadState* __tstate = wxPyBeginAllowThreads();
48905 (arg1)->SetInitSize(arg2,arg3);
48906 wxPyEndAllowThreads(__tstate);
48907 if (PyErr_Occurred()) SWIG_fail;
48908 }
48909 resultobj = SWIG_Py_Void();
48910 return resultobj;
48911 fail:
48912 return NULL;
48913 }
48914
48915
48916 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48917 PyObject *resultobj = 0;
48918 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48919 int arg2 ;
48920 int arg3 ;
48921 void *argp1 = 0 ;
48922 int res1 = 0 ;
48923 int val2 ;
48924 int ecode2 = 0 ;
48925 int val3 ;
48926 int ecode3 = 0 ;
48927 PyObject * obj0 = 0 ;
48928 PyObject * obj1 = 0 ;
48929 PyObject * obj2 = 0 ;
48930 char * kwnames[] = {
48931 (char *) "self",(char *) "width",(char *) "height", NULL
48932 };
48933
48934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48936 if (!SWIG_IsOK(res1)) {
48937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48938 }
48939 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48940 ecode2 = SWIG_AsVal_int(obj1, &val2);
48941 if (!SWIG_IsOK(ecode2)) {
48942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48943 }
48944 arg2 = static_cast< int >(val2);
48945 ecode3 = SWIG_AsVal_int(obj2, &val3);
48946 if (!SWIG_IsOK(ecode3)) {
48947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48948 }
48949 arg3 = static_cast< int >(val3);
48950 {
48951 PyThreadState* __tstate = wxPyBeginAllowThreads();
48952 (arg1)->SetRatio(arg2,arg3);
48953 wxPyEndAllowThreads(__tstate);
48954 if (PyErr_Occurred()) SWIG_fail;
48955 }
48956 resultobj = SWIG_Py_Void();
48957 return resultobj;
48958 fail:
48959 return NULL;
48960 }
48961
48962
48963 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48964 PyObject *resultobj = 0;
48965 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48966 wxSize *arg2 = 0 ;
48967 void *argp1 = 0 ;
48968 int res1 = 0 ;
48969 wxSize temp2 ;
48970 PyObject * obj0 = 0 ;
48971 PyObject * obj1 = 0 ;
48972 char * kwnames[] = {
48973 (char *) "self",(char *) "size", NULL
48974 };
48975
48976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48978 if (!SWIG_IsOK(res1)) {
48979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48980 }
48981 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48982 {
48983 arg2 = &temp2;
48984 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48985 }
48986 {
48987 PyThreadState* __tstate = wxPyBeginAllowThreads();
48988 (arg1)->SetRatio((wxSize const &)*arg2);
48989 wxPyEndAllowThreads(__tstate);
48990 if (PyErr_Occurred()) SWIG_fail;
48991 }
48992 resultobj = SWIG_Py_Void();
48993 return resultobj;
48994 fail:
48995 return NULL;
48996 }
48997
48998
48999 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49000 PyObject *resultobj = 0;
49001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49002 float arg2 ;
49003 void *argp1 = 0 ;
49004 int res1 = 0 ;
49005 float val2 ;
49006 int ecode2 = 0 ;
49007 PyObject * obj0 = 0 ;
49008 PyObject * obj1 = 0 ;
49009 char * kwnames[] = {
49010 (char *) "self",(char *) "ratio", NULL
49011 };
49012
49013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49015 if (!SWIG_IsOK(res1)) {
49016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49017 }
49018 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49019 ecode2 = SWIG_AsVal_float(obj1, &val2);
49020 if (!SWIG_IsOK(ecode2)) {
49021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49022 }
49023 arg2 = static_cast< float >(val2);
49024 {
49025 PyThreadState* __tstate = wxPyBeginAllowThreads();
49026 (arg1)->SetRatio(arg2);
49027 wxPyEndAllowThreads(__tstate);
49028 if (PyErr_Occurred()) SWIG_fail;
49029 }
49030 resultobj = SWIG_Py_Void();
49031 return resultobj;
49032 fail:
49033 return NULL;
49034 }
49035
49036
49037 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49038 PyObject *resultobj = 0;
49039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49040 float result;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 PyObject *swig_obj[1] ;
49044
49045 if (!args) SWIG_fail;
49046 swig_obj[0] = args;
49047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49048 if (!SWIG_IsOK(res1)) {
49049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49050 }
49051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49052 {
49053 PyThreadState* __tstate = wxPyBeginAllowThreads();
49054 result = (float)(arg1)->GetRatio();
49055 wxPyEndAllowThreads(__tstate);
49056 if (PyErr_Occurred()) SWIG_fail;
49057 }
49058 resultobj = SWIG_From_float(static_cast< float >(result));
49059 return resultobj;
49060 fail:
49061 return NULL;
49062 }
49063
49064
49065 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49066 PyObject *resultobj = 0;
49067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49068 wxRect result;
49069 void *argp1 = 0 ;
49070 int res1 = 0 ;
49071 PyObject *swig_obj[1] ;
49072
49073 if (!args) SWIG_fail;
49074 swig_obj[0] = args;
49075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49076 if (!SWIG_IsOK(res1)) {
49077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49078 }
49079 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49080 {
49081 PyThreadState* __tstate = wxPyBeginAllowThreads();
49082 result = (arg1)->GetRect();
49083 wxPyEndAllowThreads(__tstate);
49084 if (PyErr_Occurred()) SWIG_fail;
49085 }
49086 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49087 return resultobj;
49088 fail:
49089 return NULL;
49090 }
49091
49092
49093 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49094 PyObject *resultobj = 0;
49095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49096 bool result;
49097 void *argp1 = 0 ;
49098 int res1 = 0 ;
49099 PyObject *swig_obj[1] ;
49100
49101 if (!args) SWIG_fail;
49102 swig_obj[0] = args;
49103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49104 if (!SWIG_IsOK(res1)) {
49105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49106 }
49107 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49108 {
49109 PyThreadState* __tstate = wxPyBeginAllowThreads();
49110 result = (bool)(arg1)->IsWindow();
49111 wxPyEndAllowThreads(__tstate);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 {
49115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49116 }
49117 return resultobj;
49118 fail:
49119 return NULL;
49120 }
49121
49122
49123 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49124 PyObject *resultobj = 0;
49125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49126 bool result;
49127 void *argp1 = 0 ;
49128 int res1 = 0 ;
49129 PyObject *swig_obj[1] ;
49130
49131 if (!args) SWIG_fail;
49132 swig_obj[0] = args;
49133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49134 if (!SWIG_IsOK(res1)) {
49135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49136 }
49137 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49138 {
49139 PyThreadState* __tstate = wxPyBeginAllowThreads();
49140 result = (bool)(arg1)->IsSizer();
49141 wxPyEndAllowThreads(__tstate);
49142 if (PyErr_Occurred()) SWIG_fail;
49143 }
49144 {
49145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49146 }
49147 return resultobj;
49148 fail:
49149 return NULL;
49150 }
49151
49152
49153 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49154 PyObject *resultobj = 0;
49155 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49156 bool result;
49157 void *argp1 = 0 ;
49158 int res1 = 0 ;
49159 PyObject *swig_obj[1] ;
49160
49161 if (!args) SWIG_fail;
49162 swig_obj[0] = args;
49163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49164 if (!SWIG_IsOK(res1)) {
49165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49166 }
49167 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49168 {
49169 PyThreadState* __tstate = wxPyBeginAllowThreads();
49170 result = (bool)(arg1)->IsSpacer();
49171 wxPyEndAllowThreads(__tstate);
49172 if (PyErr_Occurred()) SWIG_fail;
49173 }
49174 {
49175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49176 }
49177 return resultobj;
49178 fail:
49179 return NULL;
49180 }
49181
49182
49183 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49184 PyObject *resultobj = 0;
49185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49186 int arg2 ;
49187 void *argp1 = 0 ;
49188 int res1 = 0 ;
49189 int val2 ;
49190 int ecode2 = 0 ;
49191 PyObject * obj0 = 0 ;
49192 PyObject * obj1 = 0 ;
49193 char * kwnames[] = {
49194 (char *) "self",(char *) "proportion", NULL
49195 };
49196
49197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49199 if (!SWIG_IsOK(res1)) {
49200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49201 }
49202 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49203 ecode2 = SWIG_AsVal_int(obj1, &val2);
49204 if (!SWIG_IsOK(ecode2)) {
49205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49206 }
49207 arg2 = static_cast< int >(val2);
49208 {
49209 PyThreadState* __tstate = wxPyBeginAllowThreads();
49210 (arg1)->SetProportion(arg2);
49211 wxPyEndAllowThreads(__tstate);
49212 if (PyErr_Occurred()) SWIG_fail;
49213 }
49214 resultobj = SWIG_Py_Void();
49215 return resultobj;
49216 fail:
49217 return NULL;
49218 }
49219
49220
49221 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49222 PyObject *resultobj = 0;
49223 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49224 int result;
49225 void *argp1 = 0 ;
49226 int res1 = 0 ;
49227 PyObject *swig_obj[1] ;
49228
49229 if (!args) SWIG_fail;
49230 swig_obj[0] = args;
49231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49232 if (!SWIG_IsOK(res1)) {
49233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49234 }
49235 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49236 {
49237 PyThreadState* __tstate = wxPyBeginAllowThreads();
49238 result = (int)(arg1)->GetProportion();
49239 wxPyEndAllowThreads(__tstate);
49240 if (PyErr_Occurred()) SWIG_fail;
49241 }
49242 resultobj = SWIG_From_int(static_cast< int >(result));
49243 return resultobj;
49244 fail:
49245 return NULL;
49246 }
49247
49248
49249 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49250 PyObject *resultobj = 0;
49251 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49252 int arg2 ;
49253 void *argp1 = 0 ;
49254 int res1 = 0 ;
49255 int val2 ;
49256 int ecode2 = 0 ;
49257 PyObject * obj0 = 0 ;
49258 PyObject * obj1 = 0 ;
49259 char * kwnames[] = {
49260 (char *) "self",(char *) "flag", NULL
49261 };
49262
49263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49265 if (!SWIG_IsOK(res1)) {
49266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49267 }
49268 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49269 ecode2 = SWIG_AsVal_int(obj1, &val2);
49270 if (!SWIG_IsOK(ecode2)) {
49271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49272 }
49273 arg2 = static_cast< int >(val2);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 (arg1)->SetFlag(arg2);
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 resultobj = SWIG_Py_Void();
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49288 PyObject *resultobj = 0;
49289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49290 int result;
49291 void *argp1 = 0 ;
49292 int res1 = 0 ;
49293 PyObject *swig_obj[1] ;
49294
49295 if (!args) SWIG_fail;
49296 swig_obj[0] = args;
49297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49298 if (!SWIG_IsOK(res1)) {
49299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49300 }
49301 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49302 {
49303 PyThreadState* __tstate = wxPyBeginAllowThreads();
49304 result = (int)(arg1)->GetFlag();
49305 wxPyEndAllowThreads(__tstate);
49306 if (PyErr_Occurred()) SWIG_fail;
49307 }
49308 resultobj = SWIG_From_int(static_cast< int >(result));
49309 return resultobj;
49310 fail:
49311 return NULL;
49312 }
49313
49314
49315 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49316 PyObject *resultobj = 0;
49317 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49318 int arg2 ;
49319 void *argp1 = 0 ;
49320 int res1 = 0 ;
49321 int val2 ;
49322 int ecode2 = 0 ;
49323 PyObject * obj0 = 0 ;
49324 PyObject * obj1 = 0 ;
49325 char * kwnames[] = {
49326 (char *) "self",(char *) "border", NULL
49327 };
49328
49329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49331 if (!SWIG_IsOK(res1)) {
49332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49333 }
49334 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49335 ecode2 = SWIG_AsVal_int(obj1, &val2);
49336 if (!SWIG_IsOK(ecode2)) {
49337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49338 }
49339 arg2 = static_cast< int >(val2);
49340 {
49341 PyThreadState* __tstate = wxPyBeginAllowThreads();
49342 (arg1)->SetBorder(arg2);
49343 wxPyEndAllowThreads(__tstate);
49344 if (PyErr_Occurred()) SWIG_fail;
49345 }
49346 resultobj = SWIG_Py_Void();
49347 return resultobj;
49348 fail:
49349 return NULL;
49350 }
49351
49352
49353 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49354 PyObject *resultobj = 0;
49355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49356 int result;
49357 void *argp1 = 0 ;
49358 int res1 = 0 ;
49359 PyObject *swig_obj[1] ;
49360
49361 if (!args) SWIG_fail;
49362 swig_obj[0] = args;
49363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49364 if (!SWIG_IsOK(res1)) {
49365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49366 }
49367 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49368 {
49369 PyThreadState* __tstate = wxPyBeginAllowThreads();
49370 result = (int)(arg1)->GetBorder();
49371 wxPyEndAllowThreads(__tstate);
49372 if (PyErr_Occurred()) SWIG_fail;
49373 }
49374 resultobj = SWIG_From_int(static_cast< int >(result));
49375 return resultobj;
49376 fail:
49377 return NULL;
49378 }
49379
49380
49381 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49382 PyObject *resultobj = 0;
49383 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49384 wxWindow *result = 0 ;
49385 void *argp1 = 0 ;
49386 int res1 = 0 ;
49387 PyObject *swig_obj[1] ;
49388
49389 if (!args) SWIG_fail;
49390 swig_obj[0] = args;
49391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49392 if (!SWIG_IsOK(res1)) {
49393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49394 }
49395 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49396 {
49397 PyThreadState* __tstate = wxPyBeginAllowThreads();
49398 result = (wxWindow *)(arg1)->GetWindow();
49399 wxPyEndAllowThreads(__tstate);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 {
49403 resultobj = wxPyMake_wxObject(result, 0);
49404 }
49405 return resultobj;
49406 fail:
49407 return NULL;
49408 }
49409
49410
49411 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49412 PyObject *resultobj = 0;
49413 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49414 wxWindow *arg2 = (wxWindow *) 0 ;
49415 void *argp1 = 0 ;
49416 int res1 = 0 ;
49417 void *argp2 = 0 ;
49418 int res2 = 0 ;
49419 PyObject * obj0 = 0 ;
49420 PyObject * obj1 = 0 ;
49421 char * kwnames[] = {
49422 (char *) "self",(char *) "window", NULL
49423 };
49424
49425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49427 if (!SWIG_IsOK(res1)) {
49428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49429 }
49430 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49431 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49432 if (!SWIG_IsOK(res2)) {
49433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49434 }
49435 arg2 = reinterpret_cast< wxWindow * >(argp2);
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 (arg1)->SetWindow(arg2);
49439 wxPyEndAllowThreads(__tstate);
49440 if (PyErr_Occurred()) SWIG_fail;
49441 }
49442 resultobj = SWIG_Py_Void();
49443 return resultobj;
49444 fail:
49445 return NULL;
49446 }
49447
49448
49449 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49450 PyObject *resultobj = 0;
49451 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49452 wxSizer *result = 0 ;
49453 void *argp1 = 0 ;
49454 int res1 = 0 ;
49455 PyObject *swig_obj[1] ;
49456
49457 if (!args) SWIG_fail;
49458 swig_obj[0] = args;
49459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49460 if (!SWIG_IsOK(res1)) {
49461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49462 }
49463 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49464 {
49465 PyThreadState* __tstate = wxPyBeginAllowThreads();
49466 result = (wxSizer *)(arg1)->GetSizer();
49467 wxPyEndAllowThreads(__tstate);
49468 if (PyErr_Occurred()) SWIG_fail;
49469 }
49470 {
49471 resultobj = wxPyMake_wxObject(result, (bool)0);
49472 }
49473 return resultobj;
49474 fail:
49475 return NULL;
49476 }
49477
49478
49479 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49480 PyObject *resultobj = 0;
49481 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49482 wxSizer *arg2 = (wxSizer *) 0 ;
49483 void *argp1 = 0 ;
49484 int res1 = 0 ;
49485 int res2 = 0 ;
49486 PyObject * obj0 = 0 ;
49487 PyObject * obj1 = 0 ;
49488 char * kwnames[] = {
49489 (char *) "self",(char *) "sizer", NULL
49490 };
49491
49492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49494 if (!SWIG_IsOK(res1)) {
49495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49496 }
49497 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49498 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49499 if (!SWIG_IsOK(res2)) {
49500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49501 }
49502 {
49503 PyThreadState* __tstate = wxPyBeginAllowThreads();
49504 (arg1)->SetSizer(arg2);
49505 wxPyEndAllowThreads(__tstate);
49506 if (PyErr_Occurred()) SWIG_fail;
49507 }
49508 resultobj = SWIG_Py_Void();
49509 return resultobj;
49510 fail:
49511 return NULL;
49512 }
49513
49514
49515 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49516 PyObject *resultobj = 0;
49517 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49518 wxSize result;
49519 void *argp1 = 0 ;
49520 int res1 = 0 ;
49521 PyObject *swig_obj[1] ;
49522
49523 if (!args) SWIG_fail;
49524 swig_obj[0] = args;
49525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49526 if (!SWIG_IsOK(res1)) {
49527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49528 }
49529 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49530 {
49531 PyThreadState* __tstate = wxPyBeginAllowThreads();
49532 result = (arg1)->GetSpacer();
49533 wxPyEndAllowThreads(__tstate);
49534 if (PyErr_Occurred()) SWIG_fail;
49535 }
49536 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49537 return resultobj;
49538 fail:
49539 return NULL;
49540 }
49541
49542
49543 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49544 PyObject *resultobj = 0;
49545 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49546 wxSize *arg2 = 0 ;
49547 void *argp1 = 0 ;
49548 int res1 = 0 ;
49549 wxSize temp2 ;
49550 PyObject * obj0 = 0 ;
49551 PyObject * obj1 = 0 ;
49552 char * kwnames[] = {
49553 (char *) "self",(char *) "size", NULL
49554 };
49555
49556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49558 if (!SWIG_IsOK(res1)) {
49559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49560 }
49561 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49562 {
49563 arg2 = &temp2;
49564 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49565 }
49566 {
49567 PyThreadState* __tstate = wxPyBeginAllowThreads();
49568 (arg1)->SetSpacer((wxSize const &)*arg2);
49569 wxPyEndAllowThreads(__tstate);
49570 if (PyErr_Occurred()) SWIG_fail;
49571 }
49572 resultobj = SWIG_Py_Void();
49573 return resultobj;
49574 fail:
49575 return NULL;
49576 }
49577
49578
49579 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49580 PyObject *resultobj = 0;
49581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49582 bool arg2 ;
49583 void *argp1 = 0 ;
49584 int res1 = 0 ;
49585 bool val2 ;
49586 int ecode2 = 0 ;
49587 PyObject * obj0 = 0 ;
49588 PyObject * obj1 = 0 ;
49589 char * kwnames[] = {
49590 (char *) "self",(char *) "show", NULL
49591 };
49592
49593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49595 if (!SWIG_IsOK(res1)) {
49596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49597 }
49598 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49599 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49600 if (!SWIG_IsOK(ecode2)) {
49601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49602 }
49603 arg2 = static_cast< bool >(val2);
49604 {
49605 PyThreadState* __tstate = wxPyBeginAllowThreads();
49606 (arg1)->Show(arg2);
49607 wxPyEndAllowThreads(__tstate);
49608 if (PyErr_Occurred()) SWIG_fail;
49609 }
49610 resultobj = SWIG_Py_Void();
49611 return resultobj;
49612 fail:
49613 return NULL;
49614 }
49615
49616
49617 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49618 PyObject *resultobj = 0;
49619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49620 bool result;
49621 void *argp1 = 0 ;
49622 int res1 = 0 ;
49623 PyObject *swig_obj[1] ;
49624
49625 if (!args) SWIG_fail;
49626 swig_obj[0] = args;
49627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49628 if (!SWIG_IsOK(res1)) {
49629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49630 }
49631 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49632 {
49633 PyThreadState* __tstate = wxPyBeginAllowThreads();
49634 result = (bool)(arg1)->IsShown();
49635 wxPyEndAllowThreads(__tstate);
49636 if (PyErr_Occurred()) SWIG_fail;
49637 }
49638 {
49639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49640 }
49641 return resultobj;
49642 fail:
49643 return NULL;
49644 }
49645
49646
49647 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49648 PyObject *resultobj = 0;
49649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49650 wxPoint result;
49651 void *argp1 = 0 ;
49652 int res1 = 0 ;
49653 PyObject *swig_obj[1] ;
49654
49655 if (!args) SWIG_fail;
49656 swig_obj[0] = args;
49657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49658 if (!SWIG_IsOK(res1)) {
49659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49660 }
49661 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49662 {
49663 PyThreadState* __tstate = wxPyBeginAllowThreads();
49664 result = (arg1)->GetPosition();
49665 wxPyEndAllowThreads(__tstate);
49666 if (PyErr_Occurred()) SWIG_fail;
49667 }
49668 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49669 return resultobj;
49670 fail:
49671 return NULL;
49672 }
49673
49674
49675 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49676 PyObject *resultobj = 0;
49677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49678 PyObject *result = 0 ;
49679 void *argp1 = 0 ;
49680 int res1 = 0 ;
49681 PyObject *swig_obj[1] ;
49682
49683 if (!args) SWIG_fail;
49684 swig_obj[0] = args;
49685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49686 if (!SWIG_IsOK(res1)) {
49687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49688 }
49689 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49690 {
49691 PyThreadState* __tstate = wxPyBeginAllowThreads();
49692 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49693 wxPyEndAllowThreads(__tstate);
49694 if (PyErr_Occurred()) SWIG_fail;
49695 }
49696 resultobj = result;
49697 return resultobj;
49698 fail:
49699 return NULL;
49700 }
49701
49702
49703 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49704 PyObject *resultobj = 0;
49705 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49706 PyObject *arg2 = (PyObject *) 0 ;
49707 void *argp1 = 0 ;
49708 int res1 = 0 ;
49709 PyObject * obj0 = 0 ;
49710 PyObject * obj1 = 0 ;
49711 char * kwnames[] = {
49712 (char *) "self",(char *) "userData", NULL
49713 };
49714
49715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49717 if (!SWIG_IsOK(res1)) {
49718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49719 }
49720 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49721 arg2 = obj1;
49722 {
49723 PyThreadState* __tstate = wxPyBeginAllowThreads();
49724 wxSizerItem_SetUserData(arg1,arg2);
49725 wxPyEndAllowThreads(__tstate);
49726 if (PyErr_Occurred()) SWIG_fail;
49727 }
49728 resultobj = SWIG_Py_Void();
49729 return resultobj;
49730 fail:
49731 return NULL;
49732 }
49733
49734
49735 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49736 PyObject *obj;
49737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49738 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49739 return SWIG_Py_Void();
49740 }
49741
49742 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49743 return SWIG_Python_InitShadowInstance(args);
49744 }
49745
49746 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49747 PyObject *resultobj = 0;
49748 wxSizer *arg1 = (wxSizer *) 0 ;
49749 void *argp1 = 0 ;
49750 int res1 = 0 ;
49751 PyObject *swig_obj[1] ;
49752
49753 if (!args) SWIG_fail;
49754 swig_obj[0] = args;
49755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49756 if (!SWIG_IsOK(res1)) {
49757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49758 }
49759 arg1 = reinterpret_cast< wxSizer * >(argp1);
49760 {
49761 PyThreadState* __tstate = wxPyBeginAllowThreads();
49762 delete arg1;
49763
49764 wxPyEndAllowThreads(__tstate);
49765 if (PyErr_Occurred()) SWIG_fail;
49766 }
49767 resultobj = SWIG_Py_Void();
49768 return resultobj;
49769 fail:
49770 return NULL;
49771 }
49772
49773
49774 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49775 PyObject *resultobj = 0;
49776 wxSizer *arg1 = (wxSizer *) 0 ;
49777 PyObject *arg2 = (PyObject *) 0 ;
49778 void *argp1 = 0 ;
49779 int res1 = 0 ;
49780 PyObject * obj0 = 0 ;
49781 PyObject * obj1 = 0 ;
49782 char * kwnames[] = {
49783 (char *) "self",(char *) "_self", NULL
49784 };
49785
49786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49788 if (!SWIG_IsOK(res1)) {
49789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49790 }
49791 arg1 = reinterpret_cast< wxSizer * >(argp1);
49792 arg2 = obj1;
49793 {
49794 PyThreadState* __tstate = wxPyBeginAllowThreads();
49795 wxSizer__setOORInfo(arg1,arg2);
49796 wxPyEndAllowThreads(__tstate);
49797 if (PyErr_Occurred()) SWIG_fail;
49798 }
49799 resultobj = SWIG_Py_Void();
49800 return resultobj;
49801 fail:
49802 return NULL;
49803 }
49804
49805
49806 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49807 PyObject *resultobj = 0;
49808 wxSizer *arg1 = (wxSizer *) 0 ;
49809 PyObject *arg2 = (PyObject *) 0 ;
49810 int arg3 = (int) 0 ;
49811 int arg4 = (int) 0 ;
49812 int arg5 = (int) 0 ;
49813 PyObject *arg6 = (PyObject *) NULL ;
49814 wxSizerItem *result = 0 ;
49815 void *argp1 = 0 ;
49816 int res1 = 0 ;
49817 int val3 ;
49818 int ecode3 = 0 ;
49819 int val4 ;
49820 int ecode4 = 0 ;
49821 int val5 ;
49822 int ecode5 = 0 ;
49823 PyObject * obj0 = 0 ;
49824 PyObject * obj1 = 0 ;
49825 PyObject * obj2 = 0 ;
49826 PyObject * obj3 = 0 ;
49827 PyObject * obj4 = 0 ;
49828 PyObject * obj5 = 0 ;
49829 char * kwnames[] = {
49830 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49831 };
49832
49833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49835 if (!SWIG_IsOK(res1)) {
49836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49837 }
49838 arg1 = reinterpret_cast< wxSizer * >(argp1);
49839 arg2 = obj1;
49840 if (obj2) {
49841 ecode3 = SWIG_AsVal_int(obj2, &val3);
49842 if (!SWIG_IsOK(ecode3)) {
49843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49844 }
49845 arg3 = static_cast< int >(val3);
49846 }
49847 if (obj3) {
49848 ecode4 = SWIG_AsVal_int(obj3, &val4);
49849 if (!SWIG_IsOK(ecode4)) {
49850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49851 }
49852 arg4 = static_cast< int >(val4);
49853 }
49854 if (obj4) {
49855 ecode5 = SWIG_AsVal_int(obj4, &val5);
49856 if (!SWIG_IsOK(ecode5)) {
49857 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49858 }
49859 arg5 = static_cast< int >(val5);
49860 }
49861 if (obj5) {
49862 arg6 = obj5;
49863 }
49864 {
49865 PyThreadState* __tstate = wxPyBeginAllowThreads();
49866 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49867 wxPyEndAllowThreads(__tstate);
49868 if (PyErr_Occurred()) SWIG_fail;
49869 }
49870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49871 return resultobj;
49872 fail:
49873 return NULL;
49874 }
49875
49876
49877 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49878 PyObject *resultobj = 0;
49879 wxSizer *arg1 = (wxSizer *) 0 ;
49880 int arg2 ;
49881 PyObject *arg3 = (PyObject *) 0 ;
49882 int arg4 = (int) 0 ;
49883 int arg5 = (int) 0 ;
49884 int arg6 = (int) 0 ;
49885 PyObject *arg7 = (PyObject *) NULL ;
49886 wxSizerItem *result = 0 ;
49887 void *argp1 = 0 ;
49888 int res1 = 0 ;
49889 int val2 ;
49890 int ecode2 = 0 ;
49891 int val4 ;
49892 int ecode4 = 0 ;
49893 int val5 ;
49894 int ecode5 = 0 ;
49895 int val6 ;
49896 int ecode6 = 0 ;
49897 PyObject * obj0 = 0 ;
49898 PyObject * obj1 = 0 ;
49899 PyObject * obj2 = 0 ;
49900 PyObject * obj3 = 0 ;
49901 PyObject * obj4 = 0 ;
49902 PyObject * obj5 = 0 ;
49903 PyObject * obj6 = 0 ;
49904 char * kwnames[] = {
49905 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49906 };
49907
49908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49910 if (!SWIG_IsOK(res1)) {
49911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49912 }
49913 arg1 = reinterpret_cast< wxSizer * >(argp1);
49914 ecode2 = SWIG_AsVal_int(obj1, &val2);
49915 if (!SWIG_IsOK(ecode2)) {
49916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49917 }
49918 arg2 = static_cast< int >(val2);
49919 arg3 = obj2;
49920 if (obj3) {
49921 ecode4 = SWIG_AsVal_int(obj3, &val4);
49922 if (!SWIG_IsOK(ecode4)) {
49923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49924 }
49925 arg4 = static_cast< int >(val4);
49926 }
49927 if (obj4) {
49928 ecode5 = SWIG_AsVal_int(obj4, &val5);
49929 if (!SWIG_IsOK(ecode5)) {
49930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49931 }
49932 arg5 = static_cast< int >(val5);
49933 }
49934 if (obj5) {
49935 ecode6 = SWIG_AsVal_int(obj5, &val6);
49936 if (!SWIG_IsOK(ecode6)) {
49937 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49938 }
49939 arg6 = static_cast< int >(val6);
49940 }
49941 if (obj6) {
49942 arg7 = obj6;
49943 }
49944 {
49945 PyThreadState* __tstate = wxPyBeginAllowThreads();
49946 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49947 wxPyEndAllowThreads(__tstate);
49948 if (PyErr_Occurred()) SWIG_fail;
49949 }
49950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49951 return resultobj;
49952 fail:
49953 return NULL;
49954 }
49955
49956
49957 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49958 PyObject *resultobj = 0;
49959 wxSizer *arg1 = (wxSizer *) 0 ;
49960 PyObject *arg2 = (PyObject *) 0 ;
49961 int arg3 = (int) 0 ;
49962 int arg4 = (int) 0 ;
49963 int arg5 = (int) 0 ;
49964 PyObject *arg6 = (PyObject *) NULL ;
49965 wxSizerItem *result = 0 ;
49966 void *argp1 = 0 ;
49967 int res1 = 0 ;
49968 int val3 ;
49969 int ecode3 = 0 ;
49970 int val4 ;
49971 int ecode4 = 0 ;
49972 int val5 ;
49973 int ecode5 = 0 ;
49974 PyObject * obj0 = 0 ;
49975 PyObject * obj1 = 0 ;
49976 PyObject * obj2 = 0 ;
49977 PyObject * obj3 = 0 ;
49978 PyObject * obj4 = 0 ;
49979 PyObject * obj5 = 0 ;
49980 char * kwnames[] = {
49981 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49982 };
49983
49984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49986 if (!SWIG_IsOK(res1)) {
49987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49988 }
49989 arg1 = reinterpret_cast< wxSizer * >(argp1);
49990 arg2 = obj1;
49991 if (obj2) {
49992 ecode3 = SWIG_AsVal_int(obj2, &val3);
49993 if (!SWIG_IsOK(ecode3)) {
49994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49995 }
49996 arg3 = static_cast< int >(val3);
49997 }
49998 if (obj3) {
49999 ecode4 = SWIG_AsVal_int(obj3, &val4);
50000 if (!SWIG_IsOK(ecode4)) {
50001 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
50002 }
50003 arg4 = static_cast< int >(val4);
50004 }
50005 if (obj4) {
50006 ecode5 = SWIG_AsVal_int(obj4, &val5);
50007 if (!SWIG_IsOK(ecode5)) {
50008 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50009 }
50010 arg5 = static_cast< int >(val5);
50011 }
50012 if (obj5) {
50013 arg6 = obj5;
50014 }
50015 {
50016 PyThreadState* __tstate = wxPyBeginAllowThreads();
50017 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50018 wxPyEndAllowThreads(__tstate);
50019 if (PyErr_Occurred()) SWIG_fail;
50020 }
50021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50022 return resultobj;
50023 fail:
50024 return NULL;
50025 }
50026
50027
50028 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50029 PyObject *resultobj = 0;
50030 wxSizer *arg1 = (wxSizer *) 0 ;
50031 PyObject *arg2 = (PyObject *) 0 ;
50032 bool result;
50033 void *argp1 = 0 ;
50034 int res1 = 0 ;
50035 PyObject * obj0 = 0 ;
50036 PyObject * obj1 = 0 ;
50037 char * kwnames[] = {
50038 (char *) "self",(char *) "item", NULL
50039 };
50040
50041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50043 if (!SWIG_IsOK(res1)) {
50044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50045 }
50046 arg1 = reinterpret_cast< wxSizer * >(argp1);
50047 arg2 = obj1;
50048 {
50049 PyThreadState* __tstate = wxPyBeginAllowThreads();
50050 result = (bool)wxSizer_Remove(arg1,arg2);
50051 wxPyEndAllowThreads(__tstate);
50052 if (PyErr_Occurred()) SWIG_fail;
50053 }
50054 {
50055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50056 }
50057 return resultobj;
50058 fail:
50059 return NULL;
50060 }
50061
50062
50063 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50064 PyObject *resultobj = 0;
50065 wxSizer *arg1 = (wxSizer *) 0 ;
50066 PyObject *arg2 = (PyObject *) 0 ;
50067 bool result;
50068 void *argp1 = 0 ;
50069 int res1 = 0 ;
50070 PyObject * obj0 = 0 ;
50071 PyObject * obj1 = 0 ;
50072 char * kwnames[] = {
50073 (char *) "self",(char *) "item", NULL
50074 };
50075
50076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50078 if (!SWIG_IsOK(res1)) {
50079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50080 }
50081 arg1 = reinterpret_cast< wxSizer * >(argp1);
50082 arg2 = obj1;
50083 {
50084 PyThreadState* __tstate = wxPyBeginAllowThreads();
50085 result = (bool)wxSizer_Detach(arg1,arg2);
50086 wxPyEndAllowThreads(__tstate);
50087 if (PyErr_Occurred()) SWIG_fail;
50088 }
50089 {
50090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50091 }
50092 return resultobj;
50093 fail:
50094 return NULL;
50095 }
50096
50097
50098 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50099 PyObject *resultobj = 0;
50100 wxSizer *arg1 = (wxSizer *) 0 ;
50101 PyObject *arg2 = (PyObject *) 0 ;
50102 wxSizerItem *result = 0 ;
50103 void *argp1 = 0 ;
50104 int res1 = 0 ;
50105 PyObject * obj0 = 0 ;
50106 PyObject * obj1 = 0 ;
50107 char * kwnames[] = {
50108 (char *) "self",(char *) "item", NULL
50109 };
50110
50111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50113 if (!SWIG_IsOK(res1)) {
50114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50115 }
50116 arg1 = reinterpret_cast< wxSizer * >(argp1);
50117 arg2 = obj1;
50118 {
50119 PyThreadState* __tstate = wxPyBeginAllowThreads();
50120 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50121 wxPyEndAllowThreads(__tstate);
50122 if (PyErr_Occurred()) SWIG_fail;
50123 }
50124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50125 return resultobj;
50126 fail:
50127 return NULL;
50128 }
50129
50130
50131 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50132 PyObject *resultobj = 0;
50133 wxSizer *arg1 = (wxSizer *) 0 ;
50134 PyObject *arg2 = (PyObject *) 0 ;
50135 wxSize *arg3 = 0 ;
50136 void *argp1 = 0 ;
50137 int res1 = 0 ;
50138 wxSize temp3 ;
50139 PyObject * obj0 = 0 ;
50140 PyObject * obj1 = 0 ;
50141 PyObject * obj2 = 0 ;
50142 char * kwnames[] = {
50143 (char *) "self",(char *) "item",(char *) "size", NULL
50144 };
50145
50146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50148 if (!SWIG_IsOK(res1)) {
50149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50150 }
50151 arg1 = reinterpret_cast< wxSizer * >(argp1);
50152 arg2 = obj1;
50153 {
50154 arg3 = &temp3;
50155 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50156 }
50157 {
50158 PyThreadState* __tstate = wxPyBeginAllowThreads();
50159 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50160 wxPyEndAllowThreads(__tstate);
50161 if (PyErr_Occurred()) SWIG_fail;
50162 }
50163 resultobj = SWIG_Py_Void();
50164 return resultobj;
50165 fail:
50166 return NULL;
50167 }
50168
50169
50170 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50171 PyObject *resultobj = 0;
50172 wxSizer *arg1 = (wxSizer *) 0 ;
50173 wxWindow *arg2 = (wxWindow *) 0 ;
50174 wxWindow *arg3 = (wxWindow *) 0 ;
50175 bool arg4 = (bool) false ;
50176 bool result;
50177 void *argp1 = 0 ;
50178 int res1 = 0 ;
50179 void *argp2 = 0 ;
50180 int res2 = 0 ;
50181 void *argp3 = 0 ;
50182 int res3 = 0 ;
50183 bool val4 ;
50184 int ecode4 = 0 ;
50185 PyObject * obj0 = 0 ;
50186 PyObject * obj1 = 0 ;
50187 PyObject * obj2 = 0 ;
50188 PyObject * obj3 = 0 ;
50189 char * kwnames[] = {
50190 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50191 };
50192
50193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50195 if (!SWIG_IsOK(res1)) {
50196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50197 }
50198 arg1 = reinterpret_cast< wxSizer * >(argp1);
50199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50200 if (!SWIG_IsOK(res2)) {
50201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50202 }
50203 arg2 = reinterpret_cast< wxWindow * >(argp2);
50204 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50205 if (!SWIG_IsOK(res3)) {
50206 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50207 }
50208 arg3 = reinterpret_cast< wxWindow * >(argp3);
50209 if (obj3) {
50210 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50211 if (!SWIG_IsOK(ecode4)) {
50212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50213 }
50214 arg4 = static_cast< bool >(val4);
50215 }
50216 {
50217 PyThreadState* __tstate = wxPyBeginAllowThreads();
50218 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50219 wxPyEndAllowThreads(__tstate);
50220 if (PyErr_Occurred()) SWIG_fail;
50221 }
50222 {
50223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50224 }
50225 return resultobj;
50226 fail:
50227 return NULL;
50228 }
50229
50230
50231 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50232 PyObject *resultobj = 0;
50233 wxSizer *arg1 = (wxSizer *) 0 ;
50234 wxSizer *arg2 = (wxSizer *) 0 ;
50235 wxSizer *arg3 = (wxSizer *) 0 ;
50236 bool arg4 = (bool) false ;
50237 bool result;
50238 void *argp1 = 0 ;
50239 int res1 = 0 ;
50240 void *argp2 = 0 ;
50241 int res2 = 0 ;
50242 void *argp3 = 0 ;
50243 int res3 = 0 ;
50244 bool val4 ;
50245 int ecode4 = 0 ;
50246 PyObject * obj0 = 0 ;
50247 PyObject * obj1 = 0 ;
50248 PyObject * obj2 = 0 ;
50249 PyObject * obj3 = 0 ;
50250 char * kwnames[] = {
50251 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50252 };
50253
50254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50256 if (!SWIG_IsOK(res1)) {
50257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50258 }
50259 arg1 = reinterpret_cast< wxSizer * >(argp1);
50260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50261 if (!SWIG_IsOK(res2)) {
50262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50263 }
50264 arg2 = reinterpret_cast< wxSizer * >(argp2);
50265 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50266 if (!SWIG_IsOK(res3)) {
50267 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50268 }
50269 arg3 = reinterpret_cast< wxSizer * >(argp3);
50270 if (obj3) {
50271 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50272 if (!SWIG_IsOK(ecode4)) {
50273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50274 }
50275 arg4 = static_cast< bool >(val4);
50276 }
50277 {
50278 PyThreadState* __tstate = wxPyBeginAllowThreads();
50279 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50280 wxPyEndAllowThreads(__tstate);
50281 if (PyErr_Occurred()) SWIG_fail;
50282 }
50283 {
50284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50285 }
50286 return resultobj;
50287 fail:
50288 return NULL;
50289 }
50290
50291
50292 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50293 PyObject *resultobj = 0;
50294 wxSizer *arg1 = (wxSizer *) 0 ;
50295 size_t arg2 ;
50296 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50297 bool result;
50298 void *argp1 = 0 ;
50299 int res1 = 0 ;
50300 size_t val2 ;
50301 int ecode2 = 0 ;
50302 void *argp3 = 0 ;
50303 int res3 = 0 ;
50304 PyObject * obj0 = 0 ;
50305 PyObject * obj1 = 0 ;
50306 PyObject * obj2 = 0 ;
50307 char * kwnames[] = {
50308 (char *) "self",(char *) "index",(char *) "newitem", NULL
50309 };
50310
50311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50313 if (!SWIG_IsOK(res1)) {
50314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50315 }
50316 arg1 = reinterpret_cast< wxSizer * >(argp1);
50317 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50318 if (!SWIG_IsOK(ecode2)) {
50319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50320 }
50321 arg2 = static_cast< size_t >(val2);
50322 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50323 if (!SWIG_IsOK(res3)) {
50324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50325 }
50326 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50327 {
50328 PyThreadState* __tstate = wxPyBeginAllowThreads();
50329 result = (bool)(arg1)->Replace(arg2,arg3);
50330 wxPyEndAllowThreads(__tstate);
50331 if (PyErr_Occurred()) SWIG_fail;
50332 }
50333 {
50334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50335 }
50336 return resultobj;
50337 fail:
50338 return NULL;
50339 }
50340
50341
50342 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50343 PyObject *resultobj = 0;
50344 wxSizer *arg1 = (wxSizer *) 0 ;
50345 wxWindow *arg2 = (wxWindow *) 0 ;
50346 void *argp1 = 0 ;
50347 int res1 = 0 ;
50348 void *argp2 = 0 ;
50349 int res2 = 0 ;
50350 PyObject * obj0 = 0 ;
50351 PyObject * obj1 = 0 ;
50352 char * kwnames[] = {
50353 (char *) "self",(char *) "window", NULL
50354 };
50355
50356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50358 if (!SWIG_IsOK(res1)) {
50359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50360 }
50361 arg1 = reinterpret_cast< wxSizer * >(argp1);
50362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50363 if (!SWIG_IsOK(res2)) {
50364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50365 }
50366 arg2 = reinterpret_cast< wxWindow * >(argp2);
50367 {
50368 PyThreadState* __tstate = wxPyBeginAllowThreads();
50369 (arg1)->SetContainingWindow(arg2);
50370 wxPyEndAllowThreads(__tstate);
50371 if (PyErr_Occurred()) SWIG_fail;
50372 }
50373 resultobj = SWIG_Py_Void();
50374 return resultobj;
50375 fail:
50376 return NULL;
50377 }
50378
50379
50380 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50381 PyObject *resultobj = 0;
50382 wxSizer *arg1 = (wxSizer *) 0 ;
50383 wxWindow *result = 0 ;
50384 void *argp1 = 0 ;
50385 int res1 = 0 ;
50386 PyObject *swig_obj[1] ;
50387
50388 if (!args) SWIG_fail;
50389 swig_obj[0] = args;
50390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50391 if (!SWIG_IsOK(res1)) {
50392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50393 }
50394 arg1 = reinterpret_cast< wxSizer * >(argp1);
50395 {
50396 PyThreadState* __tstate = wxPyBeginAllowThreads();
50397 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50398 wxPyEndAllowThreads(__tstate);
50399 if (PyErr_Occurred()) SWIG_fail;
50400 }
50401 {
50402 resultobj = wxPyMake_wxObject(result, 0);
50403 }
50404 return resultobj;
50405 fail:
50406 return NULL;
50407 }
50408
50409
50410 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50411 PyObject *resultobj = 0;
50412 wxSizer *arg1 = (wxSizer *) 0 ;
50413 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50414 wxSizerItem *result = 0 ;
50415 void *argp1 = 0 ;
50416 int res1 = 0 ;
50417 int res2 = 0 ;
50418 PyObject * obj0 = 0 ;
50419 PyObject * obj1 = 0 ;
50420 char * kwnames[] = {
50421 (char *) "self",(char *) "item", NULL
50422 };
50423
50424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50426 if (!SWIG_IsOK(res1)) {
50427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50428 }
50429 arg1 = reinterpret_cast< wxSizer * >(argp1);
50430 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50431 if (!SWIG_IsOK(res2)) {
50432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50433 }
50434 {
50435 PyThreadState* __tstate = wxPyBeginAllowThreads();
50436 result = (wxSizerItem *)(arg1)->Add(arg2);
50437 wxPyEndAllowThreads(__tstate);
50438 if (PyErr_Occurred()) SWIG_fail;
50439 }
50440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50441 return resultobj;
50442 fail:
50443 return NULL;
50444 }
50445
50446
50447 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50448 PyObject *resultobj = 0;
50449 wxSizer *arg1 = (wxSizer *) 0 ;
50450 size_t arg2 ;
50451 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50452 wxSizerItem *result = 0 ;
50453 void *argp1 = 0 ;
50454 int res1 = 0 ;
50455 size_t val2 ;
50456 int ecode2 = 0 ;
50457 int res3 = 0 ;
50458 PyObject * obj0 = 0 ;
50459 PyObject * obj1 = 0 ;
50460 PyObject * obj2 = 0 ;
50461 char * kwnames[] = {
50462 (char *) "self",(char *) "index",(char *) "item", NULL
50463 };
50464
50465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50467 if (!SWIG_IsOK(res1)) {
50468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50469 }
50470 arg1 = reinterpret_cast< wxSizer * >(argp1);
50471 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50472 if (!SWIG_IsOK(ecode2)) {
50473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50474 }
50475 arg2 = static_cast< size_t >(val2);
50476 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50477 if (!SWIG_IsOK(res3)) {
50478 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50479 }
50480 {
50481 PyThreadState* __tstate = wxPyBeginAllowThreads();
50482 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50483 wxPyEndAllowThreads(__tstate);
50484 if (PyErr_Occurred()) SWIG_fail;
50485 }
50486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50487 return resultobj;
50488 fail:
50489 return NULL;
50490 }
50491
50492
50493 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50494 PyObject *resultobj = 0;
50495 wxSizer *arg1 = (wxSizer *) 0 ;
50496 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50497 wxSizerItem *result = 0 ;
50498 void *argp1 = 0 ;
50499 int res1 = 0 ;
50500 int res2 = 0 ;
50501 PyObject * obj0 = 0 ;
50502 PyObject * obj1 = 0 ;
50503 char * kwnames[] = {
50504 (char *) "self",(char *) "item", NULL
50505 };
50506
50507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50509 if (!SWIG_IsOK(res1)) {
50510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50511 }
50512 arg1 = reinterpret_cast< wxSizer * >(argp1);
50513 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50514 if (!SWIG_IsOK(res2)) {
50515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50516 }
50517 {
50518 PyThreadState* __tstate = wxPyBeginAllowThreads();
50519 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50520 wxPyEndAllowThreads(__tstate);
50521 if (PyErr_Occurred()) SWIG_fail;
50522 }
50523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50524 return resultobj;
50525 fail:
50526 return NULL;
50527 }
50528
50529
50530 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50531 PyObject *resultobj = 0;
50532 wxSizer *arg1 = (wxSizer *) 0 ;
50533 int arg2 ;
50534 int arg3 ;
50535 int arg4 ;
50536 int arg5 ;
50537 void *argp1 = 0 ;
50538 int res1 = 0 ;
50539 int val2 ;
50540 int ecode2 = 0 ;
50541 int val3 ;
50542 int ecode3 = 0 ;
50543 int val4 ;
50544 int ecode4 = 0 ;
50545 int val5 ;
50546 int ecode5 = 0 ;
50547 PyObject * obj0 = 0 ;
50548 PyObject * obj1 = 0 ;
50549 PyObject * obj2 = 0 ;
50550 PyObject * obj3 = 0 ;
50551 PyObject * obj4 = 0 ;
50552 char * kwnames[] = {
50553 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50554 };
50555
50556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50558 if (!SWIG_IsOK(res1)) {
50559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50560 }
50561 arg1 = reinterpret_cast< wxSizer * >(argp1);
50562 ecode2 = SWIG_AsVal_int(obj1, &val2);
50563 if (!SWIG_IsOK(ecode2)) {
50564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50565 }
50566 arg2 = static_cast< int >(val2);
50567 ecode3 = SWIG_AsVal_int(obj2, &val3);
50568 if (!SWIG_IsOK(ecode3)) {
50569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50570 }
50571 arg3 = static_cast< int >(val3);
50572 ecode4 = SWIG_AsVal_int(obj3, &val4);
50573 if (!SWIG_IsOK(ecode4)) {
50574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50575 }
50576 arg4 = static_cast< int >(val4);
50577 ecode5 = SWIG_AsVal_int(obj4, &val5);
50578 if (!SWIG_IsOK(ecode5)) {
50579 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50580 }
50581 arg5 = static_cast< int >(val5);
50582 {
50583 PyThreadState* __tstate = wxPyBeginAllowThreads();
50584 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50585 wxPyEndAllowThreads(__tstate);
50586 if (PyErr_Occurred()) SWIG_fail;
50587 }
50588 resultobj = SWIG_Py_Void();
50589 return resultobj;
50590 fail:
50591 return NULL;
50592 }
50593
50594
50595 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50596 PyObject *resultobj = 0;
50597 wxSizer *arg1 = (wxSizer *) 0 ;
50598 wxSize *arg2 = 0 ;
50599 void *argp1 = 0 ;
50600 int res1 = 0 ;
50601 wxSize temp2 ;
50602 PyObject * obj0 = 0 ;
50603 PyObject * obj1 = 0 ;
50604 char * kwnames[] = {
50605 (char *) "self",(char *) "size", NULL
50606 };
50607
50608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50610 if (!SWIG_IsOK(res1)) {
50611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50612 }
50613 arg1 = reinterpret_cast< wxSizer * >(argp1);
50614 {
50615 arg2 = &temp2;
50616 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50617 }
50618 {
50619 PyThreadState* __tstate = wxPyBeginAllowThreads();
50620 (arg1)->SetMinSize((wxSize const &)*arg2);
50621 wxPyEndAllowThreads(__tstate);
50622 if (PyErr_Occurred()) SWIG_fail;
50623 }
50624 resultobj = SWIG_Py_Void();
50625 return resultobj;
50626 fail:
50627 return NULL;
50628 }
50629
50630
50631 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50632 PyObject *resultobj = 0;
50633 wxSizer *arg1 = (wxSizer *) 0 ;
50634 wxSize result;
50635 void *argp1 = 0 ;
50636 int res1 = 0 ;
50637 PyObject *swig_obj[1] ;
50638
50639 if (!args) SWIG_fail;
50640 swig_obj[0] = args;
50641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50642 if (!SWIG_IsOK(res1)) {
50643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50644 }
50645 arg1 = reinterpret_cast< wxSizer * >(argp1);
50646 {
50647 PyThreadState* __tstate = wxPyBeginAllowThreads();
50648 result = (arg1)->GetSize();
50649 wxPyEndAllowThreads(__tstate);
50650 if (PyErr_Occurred()) SWIG_fail;
50651 }
50652 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50653 return resultobj;
50654 fail:
50655 return NULL;
50656 }
50657
50658
50659 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50660 PyObject *resultobj = 0;
50661 wxSizer *arg1 = (wxSizer *) 0 ;
50662 wxPoint result;
50663 void *argp1 = 0 ;
50664 int res1 = 0 ;
50665 PyObject *swig_obj[1] ;
50666
50667 if (!args) SWIG_fail;
50668 swig_obj[0] = args;
50669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50670 if (!SWIG_IsOK(res1)) {
50671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50672 }
50673 arg1 = reinterpret_cast< wxSizer * >(argp1);
50674 {
50675 PyThreadState* __tstate = wxPyBeginAllowThreads();
50676 result = (arg1)->GetPosition();
50677 wxPyEndAllowThreads(__tstate);
50678 if (PyErr_Occurred()) SWIG_fail;
50679 }
50680 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50681 return resultobj;
50682 fail:
50683 return NULL;
50684 }
50685
50686
50687 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50688 PyObject *resultobj = 0;
50689 wxSizer *arg1 = (wxSizer *) 0 ;
50690 wxSize result;
50691 void *argp1 = 0 ;
50692 int res1 = 0 ;
50693 PyObject *swig_obj[1] ;
50694
50695 if (!args) SWIG_fail;
50696 swig_obj[0] = args;
50697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50698 if (!SWIG_IsOK(res1)) {
50699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50700 }
50701 arg1 = reinterpret_cast< wxSizer * >(argp1);
50702 {
50703 PyThreadState* __tstate = wxPyBeginAllowThreads();
50704 result = (arg1)->GetMinSize();
50705 wxPyEndAllowThreads(__tstate);
50706 if (PyErr_Occurred()) SWIG_fail;
50707 }
50708 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50709 return resultobj;
50710 fail:
50711 return NULL;
50712 }
50713
50714
50715 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50716 PyObject *resultobj = 0;
50717 wxSizer *arg1 = (wxSizer *) 0 ;
50718 void *argp1 = 0 ;
50719 int res1 = 0 ;
50720 PyObject *swig_obj[1] ;
50721
50722 if (!args) SWIG_fail;
50723 swig_obj[0] = args;
50724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50725 if (!SWIG_IsOK(res1)) {
50726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50727 }
50728 arg1 = reinterpret_cast< wxSizer * >(argp1);
50729 {
50730 PyThreadState* __tstate = wxPyBeginAllowThreads();
50731 (arg1)->RecalcSizes();
50732 wxPyEndAllowThreads(__tstate);
50733 if (PyErr_Occurred()) SWIG_fail;
50734 }
50735 resultobj = SWIG_Py_Void();
50736 return resultobj;
50737 fail:
50738 return NULL;
50739 }
50740
50741
50742 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50743 PyObject *resultobj = 0;
50744 wxSizer *arg1 = (wxSizer *) 0 ;
50745 wxSize result;
50746 void *argp1 = 0 ;
50747 int res1 = 0 ;
50748 PyObject *swig_obj[1] ;
50749
50750 if (!args) SWIG_fail;
50751 swig_obj[0] = args;
50752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50753 if (!SWIG_IsOK(res1)) {
50754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50755 }
50756 arg1 = reinterpret_cast< wxSizer * >(argp1);
50757 {
50758 PyThreadState* __tstate = wxPyBeginAllowThreads();
50759 result = (arg1)->CalcMin();
50760 wxPyEndAllowThreads(__tstate);
50761 if (PyErr_Occurred()) SWIG_fail;
50762 }
50763 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50764 return resultobj;
50765 fail:
50766 return NULL;
50767 }
50768
50769
50770 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50771 PyObject *resultobj = 0;
50772 wxSizer *arg1 = (wxSizer *) 0 ;
50773 void *argp1 = 0 ;
50774 int res1 = 0 ;
50775 PyObject *swig_obj[1] ;
50776
50777 if (!args) SWIG_fail;
50778 swig_obj[0] = args;
50779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50780 if (!SWIG_IsOK(res1)) {
50781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50782 }
50783 arg1 = reinterpret_cast< wxSizer * >(argp1);
50784 {
50785 PyThreadState* __tstate = wxPyBeginAllowThreads();
50786 (arg1)->Layout();
50787 wxPyEndAllowThreads(__tstate);
50788 if (PyErr_Occurred()) SWIG_fail;
50789 }
50790 resultobj = SWIG_Py_Void();
50791 return resultobj;
50792 fail:
50793 return NULL;
50794 }
50795
50796
50797 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50798 PyObject *resultobj = 0;
50799 wxSizer *arg1 = (wxSizer *) 0 ;
50800 wxWindow *arg2 = (wxWindow *) 0 ;
50801 wxSize result;
50802 void *argp1 = 0 ;
50803 int res1 = 0 ;
50804 void *argp2 = 0 ;
50805 int res2 = 0 ;
50806 PyObject * obj0 = 0 ;
50807 PyObject * obj1 = 0 ;
50808 char * kwnames[] = {
50809 (char *) "self",(char *) "window", NULL
50810 };
50811
50812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50814 if (!SWIG_IsOK(res1)) {
50815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50816 }
50817 arg1 = reinterpret_cast< wxSizer * >(argp1);
50818 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50819 if (!SWIG_IsOK(res2)) {
50820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50821 }
50822 arg2 = reinterpret_cast< wxWindow * >(argp2);
50823 {
50824 PyThreadState* __tstate = wxPyBeginAllowThreads();
50825 result = (arg1)->Fit(arg2);
50826 wxPyEndAllowThreads(__tstate);
50827 if (PyErr_Occurred()) SWIG_fail;
50828 }
50829 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50830 return resultobj;
50831 fail:
50832 return NULL;
50833 }
50834
50835
50836 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50837 PyObject *resultobj = 0;
50838 wxSizer *arg1 = (wxSizer *) 0 ;
50839 wxWindow *arg2 = (wxWindow *) 0 ;
50840 void *argp1 = 0 ;
50841 int res1 = 0 ;
50842 void *argp2 = 0 ;
50843 int res2 = 0 ;
50844 PyObject * obj0 = 0 ;
50845 PyObject * obj1 = 0 ;
50846 char * kwnames[] = {
50847 (char *) "self",(char *) "window", NULL
50848 };
50849
50850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50852 if (!SWIG_IsOK(res1)) {
50853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50854 }
50855 arg1 = reinterpret_cast< wxSizer * >(argp1);
50856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50857 if (!SWIG_IsOK(res2)) {
50858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50859 }
50860 arg2 = reinterpret_cast< wxWindow * >(argp2);
50861 {
50862 PyThreadState* __tstate = wxPyBeginAllowThreads();
50863 (arg1)->FitInside(arg2);
50864 wxPyEndAllowThreads(__tstate);
50865 if (PyErr_Occurred()) SWIG_fail;
50866 }
50867 resultobj = SWIG_Py_Void();
50868 return resultobj;
50869 fail:
50870 return NULL;
50871 }
50872
50873
50874 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50875 PyObject *resultobj = 0;
50876 wxSizer *arg1 = (wxSizer *) 0 ;
50877 wxWindow *arg2 = (wxWindow *) 0 ;
50878 void *argp1 = 0 ;
50879 int res1 = 0 ;
50880 void *argp2 = 0 ;
50881 int res2 = 0 ;
50882 PyObject * obj0 = 0 ;
50883 PyObject * obj1 = 0 ;
50884 char * kwnames[] = {
50885 (char *) "self",(char *) "window", NULL
50886 };
50887
50888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50890 if (!SWIG_IsOK(res1)) {
50891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50892 }
50893 arg1 = reinterpret_cast< wxSizer * >(argp1);
50894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50895 if (!SWIG_IsOK(res2)) {
50896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50897 }
50898 arg2 = reinterpret_cast< wxWindow * >(argp2);
50899 {
50900 PyThreadState* __tstate = wxPyBeginAllowThreads();
50901 (arg1)->SetSizeHints(arg2);
50902 wxPyEndAllowThreads(__tstate);
50903 if (PyErr_Occurred()) SWIG_fail;
50904 }
50905 resultobj = SWIG_Py_Void();
50906 return resultobj;
50907 fail:
50908 return NULL;
50909 }
50910
50911
50912 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50913 PyObject *resultobj = 0;
50914 wxSizer *arg1 = (wxSizer *) 0 ;
50915 wxWindow *arg2 = (wxWindow *) 0 ;
50916 void *argp1 = 0 ;
50917 int res1 = 0 ;
50918 void *argp2 = 0 ;
50919 int res2 = 0 ;
50920 PyObject * obj0 = 0 ;
50921 PyObject * obj1 = 0 ;
50922 char * kwnames[] = {
50923 (char *) "self",(char *) "window", NULL
50924 };
50925
50926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50928 if (!SWIG_IsOK(res1)) {
50929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50930 }
50931 arg1 = reinterpret_cast< wxSizer * >(argp1);
50932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50933 if (!SWIG_IsOK(res2)) {
50934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50935 }
50936 arg2 = reinterpret_cast< wxWindow * >(argp2);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 (arg1)->SetVirtualSizeHints(arg2);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = SWIG_Py_Void();
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxSizer *arg1 = (wxSizer *) 0 ;
50953 bool arg2 = (bool) false ;
50954 void *argp1 = 0 ;
50955 int res1 = 0 ;
50956 bool val2 ;
50957 int ecode2 = 0 ;
50958 PyObject * obj0 = 0 ;
50959 PyObject * obj1 = 0 ;
50960 char * kwnames[] = {
50961 (char *) "self",(char *) "deleteWindows", NULL
50962 };
50963
50964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50966 if (!SWIG_IsOK(res1)) {
50967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50968 }
50969 arg1 = reinterpret_cast< wxSizer * >(argp1);
50970 if (obj1) {
50971 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50972 if (!SWIG_IsOK(ecode2)) {
50973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50974 }
50975 arg2 = static_cast< bool >(val2);
50976 }
50977 {
50978 PyThreadState* __tstate = wxPyBeginAllowThreads();
50979 (arg1)->Clear(arg2);
50980 wxPyEndAllowThreads(__tstate);
50981 if (PyErr_Occurred()) SWIG_fail;
50982 }
50983 resultobj = SWIG_Py_Void();
50984 return resultobj;
50985 fail:
50986 return NULL;
50987 }
50988
50989
50990 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50991 PyObject *resultobj = 0;
50992 wxSizer *arg1 = (wxSizer *) 0 ;
50993 void *argp1 = 0 ;
50994 int res1 = 0 ;
50995 PyObject *swig_obj[1] ;
50996
50997 if (!args) SWIG_fail;
50998 swig_obj[0] = args;
50999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51000 if (!SWIG_IsOK(res1)) {
51001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
51002 }
51003 arg1 = reinterpret_cast< wxSizer * >(argp1);
51004 {
51005 PyThreadState* __tstate = wxPyBeginAllowThreads();
51006 (arg1)->DeleteWindows();
51007 wxPyEndAllowThreads(__tstate);
51008 if (PyErr_Occurred()) SWIG_fail;
51009 }
51010 resultobj = SWIG_Py_Void();
51011 return resultobj;
51012 fail:
51013 return NULL;
51014 }
51015
51016
51017 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51018 PyObject *resultobj = 0;
51019 wxSizer *arg1 = (wxSizer *) 0 ;
51020 PyObject *result = 0 ;
51021 void *argp1 = 0 ;
51022 int res1 = 0 ;
51023 PyObject *swig_obj[1] ;
51024
51025 if (!args) SWIG_fail;
51026 swig_obj[0] = args;
51027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51028 if (!SWIG_IsOK(res1)) {
51029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51030 }
51031 arg1 = reinterpret_cast< wxSizer * >(argp1);
51032 {
51033 PyThreadState* __tstate = wxPyBeginAllowThreads();
51034 result = (PyObject *)wxSizer_GetChildren(arg1);
51035 wxPyEndAllowThreads(__tstate);
51036 if (PyErr_Occurred()) SWIG_fail;
51037 }
51038 resultobj = result;
51039 return resultobj;
51040 fail:
51041 return NULL;
51042 }
51043
51044
51045 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51046 PyObject *resultobj = 0;
51047 wxSizer *arg1 = (wxSizer *) 0 ;
51048 PyObject *arg2 = (PyObject *) 0 ;
51049 bool arg3 = (bool) true ;
51050 bool arg4 = (bool) false ;
51051 bool result;
51052 void *argp1 = 0 ;
51053 int res1 = 0 ;
51054 bool val3 ;
51055 int ecode3 = 0 ;
51056 bool val4 ;
51057 int ecode4 = 0 ;
51058 PyObject * obj0 = 0 ;
51059 PyObject * obj1 = 0 ;
51060 PyObject * obj2 = 0 ;
51061 PyObject * obj3 = 0 ;
51062 char * kwnames[] = {
51063 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51064 };
51065
51066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51068 if (!SWIG_IsOK(res1)) {
51069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51070 }
51071 arg1 = reinterpret_cast< wxSizer * >(argp1);
51072 arg2 = obj1;
51073 if (obj2) {
51074 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51075 if (!SWIG_IsOK(ecode3)) {
51076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51077 }
51078 arg3 = static_cast< bool >(val3);
51079 }
51080 if (obj3) {
51081 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51082 if (!SWIG_IsOK(ecode4)) {
51083 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51084 }
51085 arg4 = static_cast< bool >(val4);
51086 }
51087 {
51088 PyThreadState* __tstate = wxPyBeginAllowThreads();
51089 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51090 wxPyEndAllowThreads(__tstate);
51091 if (PyErr_Occurred()) SWIG_fail;
51092 }
51093 {
51094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51095 }
51096 return resultobj;
51097 fail:
51098 return NULL;
51099 }
51100
51101
51102 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51103 PyObject *resultobj = 0;
51104 wxSizer *arg1 = (wxSizer *) 0 ;
51105 PyObject *arg2 = (PyObject *) 0 ;
51106 bool result;
51107 void *argp1 = 0 ;
51108 int res1 = 0 ;
51109 PyObject * obj0 = 0 ;
51110 PyObject * obj1 = 0 ;
51111 char * kwnames[] = {
51112 (char *) "self",(char *) "item", NULL
51113 };
51114
51115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51117 if (!SWIG_IsOK(res1)) {
51118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51119 }
51120 arg1 = reinterpret_cast< wxSizer * >(argp1);
51121 arg2 = obj1;
51122 {
51123 PyThreadState* __tstate = wxPyBeginAllowThreads();
51124 result = (bool)wxSizer_IsShown(arg1,arg2);
51125 wxPyEndAllowThreads(__tstate);
51126 if (PyErr_Occurred()) SWIG_fail;
51127 }
51128 {
51129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51130 }
51131 return resultobj;
51132 fail:
51133 return NULL;
51134 }
51135
51136
51137 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51138 PyObject *resultobj = 0;
51139 wxSizer *arg1 = (wxSizer *) 0 ;
51140 bool arg2 ;
51141 void *argp1 = 0 ;
51142 int res1 = 0 ;
51143 bool val2 ;
51144 int ecode2 = 0 ;
51145 PyObject * obj0 = 0 ;
51146 PyObject * obj1 = 0 ;
51147 char * kwnames[] = {
51148 (char *) "self",(char *) "show", NULL
51149 };
51150
51151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51153 if (!SWIG_IsOK(res1)) {
51154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51155 }
51156 arg1 = reinterpret_cast< wxSizer * >(argp1);
51157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51158 if (!SWIG_IsOK(ecode2)) {
51159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51160 }
51161 arg2 = static_cast< bool >(val2);
51162 {
51163 PyThreadState* __tstate = wxPyBeginAllowThreads();
51164 (arg1)->ShowItems(arg2);
51165 wxPyEndAllowThreads(__tstate);
51166 if (PyErr_Occurred()) SWIG_fail;
51167 }
51168 resultobj = SWIG_Py_Void();
51169 return resultobj;
51170 fail:
51171 return NULL;
51172 }
51173
51174
51175 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51176 PyObject *obj;
51177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51178 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51179 return SWIG_Py_Void();
51180 }
51181
51182 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51183 PyObject *resultobj = 0;
51184 wxPySizer *result = 0 ;
51185
51186 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51187 {
51188 PyThreadState* __tstate = wxPyBeginAllowThreads();
51189 result = (wxPySizer *)new wxPySizer();
51190 wxPyEndAllowThreads(__tstate);
51191 if (PyErr_Occurred()) SWIG_fail;
51192 }
51193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51194 return resultobj;
51195 fail:
51196 return NULL;
51197 }
51198
51199
51200 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51201 PyObject *resultobj = 0;
51202 wxPySizer *arg1 = (wxPySizer *) 0 ;
51203 PyObject *arg2 = (PyObject *) 0 ;
51204 PyObject *arg3 = (PyObject *) 0 ;
51205 void *argp1 = 0 ;
51206 int res1 = 0 ;
51207 PyObject * obj0 = 0 ;
51208 PyObject * obj1 = 0 ;
51209 PyObject * obj2 = 0 ;
51210 char * kwnames[] = {
51211 (char *) "self",(char *) "self",(char *) "_class", NULL
51212 };
51213
51214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51216 if (!SWIG_IsOK(res1)) {
51217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51218 }
51219 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51220 arg2 = obj1;
51221 arg3 = obj2;
51222 {
51223 PyThreadState* __tstate = wxPyBeginAllowThreads();
51224 (arg1)->_setCallbackInfo(arg2,arg3);
51225 wxPyEndAllowThreads(__tstate);
51226 if (PyErr_Occurred()) SWIG_fail;
51227 }
51228 resultobj = SWIG_Py_Void();
51229 return resultobj;
51230 fail:
51231 return NULL;
51232 }
51233
51234
51235 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51236 PyObject *obj;
51237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51238 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51239 return SWIG_Py_Void();
51240 }
51241
51242 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51243 return SWIG_Python_InitShadowInstance(args);
51244 }
51245
51246 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51247 PyObject *resultobj = 0;
51248 int arg1 = (int) wxHORIZONTAL ;
51249 wxBoxSizer *result = 0 ;
51250 int val1 ;
51251 int ecode1 = 0 ;
51252 PyObject * obj0 = 0 ;
51253 char * kwnames[] = {
51254 (char *) "orient", NULL
51255 };
51256
51257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51258 if (obj0) {
51259 ecode1 = SWIG_AsVal_int(obj0, &val1);
51260 if (!SWIG_IsOK(ecode1)) {
51261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51262 }
51263 arg1 = static_cast< int >(val1);
51264 }
51265 {
51266 PyThreadState* __tstate = wxPyBeginAllowThreads();
51267 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51268 wxPyEndAllowThreads(__tstate);
51269 if (PyErr_Occurred()) SWIG_fail;
51270 }
51271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51272 return resultobj;
51273 fail:
51274 return NULL;
51275 }
51276
51277
51278 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51279 PyObject *resultobj = 0;
51280 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51281 int result;
51282 void *argp1 = 0 ;
51283 int res1 = 0 ;
51284 PyObject *swig_obj[1] ;
51285
51286 if (!args) SWIG_fail;
51287 swig_obj[0] = args;
51288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51289 if (!SWIG_IsOK(res1)) {
51290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51291 }
51292 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51293 {
51294 PyThreadState* __tstate = wxPyBeginAllowThreads();
51295 result = (int)(arg1)->GetOrientation();
51296 wxPyEndAllowThreads(__tstate);
51297 if (PyErr_Occurred()) SWIG_fail;
51298 }
51299 resultobj = SWIG_From_int(static_cast< int >(result));
51300 return resultobj;
51301 fail:
51302 return NULL;
51303 }
51304
51305
51306 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51307 PyObject *resultobj = 0;
51308 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51309 int arg2 ;
51310 void *argp1 = 0 ;
51311 int res1 = 0 ;
51312 int val2 ;
51313 int ecode2 = 0 ;
51314 PyObject * obj0 = 0 ;
51315 PyObject * obj1 = 0 ;
51316 char * kwnames[] = {
51317 (char *) "self",(char *) "orient", NULL
51318 };
51319
51320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51322 if (!SWIG_IsOK(res1)) {
51323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51324 }
51325 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51326 ecode2 = SWIG_AsVal_int(obj1, &val2);
51327 if (!SWIG_IsOK(ecode2)) {
51328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51329 }
51330 arg2 = static_cast< int >(val2);
51331 {
51332 PyThreadState* __tstate = wxPyBeginAllowThreads();
51333 (arg1)->SetOrientation(arg2);
51334 wxPyEndAllowThreads(__tstate);
51335 if (PyErr_Occurred()) SWIG_fail;
51336 }
51337 resultobj = SWIG_Py_Void();
51338 return resultobj;
51339 fail:
51340 return NULL;
51341 }
51342
51343
51344 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51345 PyObject *obj;
51346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51347 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51348 return SWIG_Py_Void();
51349 }
51350
51351 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51352 return SWIG_Python_InitShadowInstance(args);
51353 }
51354
51355 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51356 PyObject *resultobj = 0;
51357 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51358 int arg2 = (int) wxHORIZONTAL ;
51359 wxStaticBoxSizer *result = 0 ;
51360 void *argp1 = 0 ;
51361 int res1 = 0 ;
51362 int val2 ;
51363 int ecode2 = 0 ;
51364 PyObject * obj0 = 0 ;
51365 PyObject * obj1 = 0 ;
51366 char * kwnames[] = {
51367 (char *) "box",(char *) "orient", NULL
51368 };
51369
51370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51372 if (!SWIG_IsOK(res1)) {
51373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51374 }
51375 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51376 if (obj1) {
51377 ecode2 = SWIG_AsVal_int(obj1, &val2);
51378 if (!SWIG_IsOK(ecode2)) {
51379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51380 }
51381 arg2 = static_cast< int >(val2);
51382 }
51383 {
51384 PyThreadState* __tstate = wxPyBeginAllowThreads();
51385 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51386 wxPyEndAllowThreads(__tstate);
51387 if (PyErr_Occurred()) SWIG_fail;
51388 }
51389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51390 return resultobj;
51391 fail:
51392 return NULL;
51393 }
51394
51395
51396 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51397 PyObject *resultobj = 0;
51398 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51399 wxStaticBox *result = 0 ;
51400 void *argp1 = 0 ;
51401 int res1 = 0 ;
51402 PyObject *swig_obj[1] ;
51403
51404 if (!args) SWIG_fail;
51405 swig_obj[0] = args;
51406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51407 if (!SWIG_IsOK(res1)) {
51408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51409 }
51410 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51411 {
51412 PyThreadState* __tstate = wxPyBeginAllowThreads();
51413 result = (wxStaticBox *)(arg1)->GetStaticBox();
51414 wxPyEndAllowThreads(__tstate);
51415 if (PyErr_Occurred()) SWIG_fail;
51416 }
51417 {
51418 resultobj = wxPyMake_wxObject(result, (bool)0);
51419 }
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51427 PyObject *obj;
51428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51429 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51430 return SWIG_Py_Void();
51431 }
51432
51433 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51434 return SWIG_Python_InitShadowInstance(args);
51435 }
51436
51437 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51438 PyObject *resultobj = 0;
51439 int arg1 = (int) 1 ;
51440 int arg2 = (int) 0 ;
51441 int arg3 = (int) 0 ;
51442 int arg4 = (int) 0 ;
51443 wxGridSizer *result = 0 ;
51444 int val1 ;
51445 int ecode1 = 0 ;
51446 int val2 ;
51447 int ecode2 = 0 ;
51448 int val3 ;
51449 int ecode3 = 0 ;
51450 int val4 ;
51451 int ecode4 = 0 ;
51452 PyObject * obj0 = 0 ;
51453 PyObject * obj1 = 0 ;
51454 PyObject * obj2 = 0 ;
51455 PyObject * obj3 = 0 ;
51456 char * kwnames[] = {
51457 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51458 };
51459
51460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51461 if (obj0) {
51462 ecode1 = SWIG_AsVal_int(obj0, &val1);
51463 if (!SWIG_IsOK(ecode1)) {
51464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51465 }
51466 arg1 = static_cast< int >(val1);
51467 }
51468 if (obj1) {
51469 ecode2 = SWIG_AsVal_int(obj1, &val2);
51470 if (!SWIG_IsOK(ecode2)) {
51471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51472 }
51473 arg2 = static_cast< int >(val2);
51474 }
51475 if (obj2) {
51476 ecode3 = SWIG_AsVal_int(obj2, &val3);
51477 if (!SWIG_IsOK(ecode3)) {
51478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51479 }
51480 arg3 = static_cast< int >(val3);
51481 }
51482 if (obj3) {
51483 ecode4 = SWIG_AsVal_int(obj3, &val4);
51484 if (!SWIG_IsOK(ecode4)) {
51485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51486 }
51487 arg4 = static_cast< int >(val4);
51488 }
51489 {
51490 PyThreadState* __tstate = wxPyBeginAllowThreads();
51491 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51492 wxPyEndAllowThreads(__tstate);
51493 if (PyErr_Occurred()) SWIG_fail;
51494 }
51495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51496 return resultobj;
51497 fail:
51498 return NULL;
51499 }
51500
51501
51502 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51503 PyObject *resultobj = 0;
51504 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51505 int arg2 ;
51506 void *argp1 = 0 ;
51507 int res1 = 0 ;
51508 int val2 ;
51509 int ecode2 = 0 ;
51510 PyObject * obj0 = 0 ;
51511 PyObject * obj1 = 0 ;
51512 char * kwnames[] = {
51513 (char *) "self",(char *) "cols", NULL
51514 };
51515
51516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51518 if (!SWIG_IsOK(res1)) {
51519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51520 }
51521 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51522 ecode2 = SWIG_AsVal_int(obj1, &val2);
51523 if (!SWIG_IsOK(ecode2)) {
51524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51525 }
51526 arg2 = static_cast< int >(val2);
51527 {
51528 PyThreadState* __tstate = wxPyBeginAllowThreads();
51529 (arg1)->SetCols(arg2);
51530 wxPyEndAllowThreads(__tstate);
51531 if (PyErr_Occurred()) SWIG_fail;
51532 }
51533 resultobj = SWIG_Py_Void();
51534 return resultobj;
51535 fail:
51536 return NULL;
51537 }
51538
51539
51540 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51541 PyObject *resultobj = 0;
51542 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51543 int arg2 ;
51544 void *argp1 = 0 ;
51545 int res1 = 0 ;
51546 int val2 ;
51547 int ecode2 = 0 ;
51548 PyObject * obj0 = 0 ;
51549 PyObject * obj1 = 0 ;
51550 char * kwnames[] = {
51551 (char *) "self",(char *) "rows", NULL
51552 };
51553
51554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51556 if (!SWIG_IsOK(res1)) {
51557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51558 }
51559 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51560 ecode2 = SWIG_AsVal_int(obj1, &val2);
51561 if (!SWIG_IsOK(ecode2)) {
51562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51563 }
51564 arg2 = static_cast< int >(val2);
51565 {
51566 PyThreadState* __tstate = wxPyBeginAllowThreads();
51567 (arg1)->SetRows(arg2);
51568 wxPyEndAllowThreads(__tstate);
51569 if (PyErr_Occurred()) SWIG_fail;
51570 }
51571 resultobj = SWIG_Py_Void();
51572 return resultobj;
51573 fail:
51574 return NULL;
51575 }
51576
51577
51578 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51579 PyObject *resultobj = 0;
51580 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51581 int arg2 ;
51582 void *argp1 = 0 ;
51583 int res1 = 0 ;
51584 int val2 ;
51585 int ecode2 = 0 ;
51586 PyObject * obj0 = 0 ;
51587 PyObject * obj1 = 0 ;
51588 char * kwnames[] = {
51589 (char *) "self",(char *) "gap", NULL
51590 };
51591
51592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51594 if (!SWIG_IsOK(res1)) {
51595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51596 }
51597 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51598 ecode2 = SWIG_AsVal_int(obj1, &val2);
51599 if (!SWIG_IsOK(ecode2)) {
51600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51601 }
51602 arg2 = static_cast< int >(val2);
51603 {
51604 PyThreadState* __tstate = wxPyBeginAllowThreads();
51605 (arg1)->SetVGap(arg2);
51606 wxPyEndAllowThreads(__tstate);
51607 if (PyErr_Occurred()) SWIG_fail;
51608 }
51609 resultobj = SWIG_Py_Void();
51610 return resultobj;
51611 fail:
51612 return NULL;
51613 }
51614
51615
51616 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51617 PyObject *resultobj = 0;
51618 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51619 int arg2 ;
51620 void *argp1 = 0 ;
51621 int res1 = 0 ;
51622 int val2 ;
51623 int ecode2 = 0 ;
51624 PyObject * obj0 = 0 ;
51625 PyObject * obj1 = 0 ;
51626 char * kwnames[] = {
51627 (char *) "self",(char *) "gap", NULL
51628 };
51629
51630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51632 if (!SWIG_IsOK(res1)) {
51633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51634 }
51635 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51636 ecode2 = SWIG_AsVal_int(obj1, &val2);
51637 if (!SWIG_IsOK(ecode2)) {
51638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51639 }
51640 arg2 = static_cast< int >(val2);
51641 {
51642 PyThreadState* __tstate = wxPyBeginAllowThreads();
51643 (arg1)->SetHGap(arg2);
51644 wxPyEndAllowThreads(__tstate);
51645 if (PyErr_Occurred()) SWIG_fail;
51646 }
51647 resultobj = SWIG_Py_Void();
51648 return resultobj;
51649 fail:
51650 return NULL;
51651 }
51652
51653
51654 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51655 PyObject *resultobj = 0;
51656 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51657 int result;
51658 void *argp1 = 0 ;
51659 int res1 = 0 ;
51660 PyObject *swig_obj[1] ;
51661
51662 if (!args) SWIG_fail;
51663 swig_obj[0] = args;
51664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51665 if (!SWIG_IsOK(res1)) {
51666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51667 }
51668 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51669 {
51670 PyThreadState* __tstate = wxPyBeginAllowThreads();
51671 result = (int)(arg1)->GetCols();
51672 wxPyEndAllowThreads(__tstate);
51673 if (PyErr_Occurred()) SWIG_fail;
51674 }
51675 resultobj = SWIG_From_int(static_cast< int >(result));
51676 return resultobj;
51677 fail:
51678 return NULL;
51679 }
51680
51681
51682 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51683 PyObject *resultobj = 0;
51684 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51685 int result;
51686 void *argp1 = 0 ;
51687 int res1 = 0 ;
51688 PyObject *swig_obj[1] ;
51689
51690 if (!args) SWIG_fail;
51691 swig_obj[0] = args;
51692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51693 if (!SWIG_IsOK(res1)) {
51694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51695 }
51696 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51697 {
51698 PyThreadState* __tstate = wxPyBeginAllowThreads();
51699 result = (int)(arg1)->GetRows();
51700 wxPyEndAllowThreads(__tstate);
51701 if (PyErr_Occurred()) SWIG_fail;
51702 }
51703 resultobj = SWIG_From_int(static_cast< int >(result));
51704 return resultobj;
51705 fail:
51706 return NULL;
51707 }
51708
51709
51710 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51711 PyObject *resultobj = 0;
51712 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51713 int result;
51714 void *argp1 = 0 ;
51715 int res1 = 0 ;
51716 PyObject *swig_obj[1] ;
51717
51718 if (!args) SWIG_fail;
51719 swig_obj[0] = args;
51720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51721 if (!SWIG_IsOK(res1)) {
51722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51723 }
51724 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51725 {
51726 PyThreadState* __tstate = wxPyBeginAllowThreads();
51727 result = (int)(arg1)->GetVGap();
51728 wxPyEndAllowThreads(__tstate);
51729 if (PyErr_Occurred()) SWIG_fail;
51730 }
51731 resultobj = SWIG_From_int(static_cast< int >(result));
51732 return resultobj;
51733 fail:
51734 return NULL;
51735 }
51736
51737
51738 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51739 PyObject *resultobj = 0;
51740 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51741 int result;
51742 void *argp1 = 0 ;
51743 int res1 = 0 ;
51744 PyObject *swig_obj[1] ;
51745
51746 if (!args) SWIG_fail;
51747 swig_obj[0] = args;
51748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51749 if (!SWIG_IsOK(res1)) {
51750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51751 }
51752 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51753 {
51754 PyThreadState* __tstate = wxPyBeginAllowThreads();
51755 result = (int)(arg1)->GetHGap();
51756 wxPyEndAllowThreads(__tstate);
51757 if (PyErr_Occurred()) SWIG_fail;
51758 }
51759 resultobj = SWIG_From_int(static_cast< int >(result));
51760 return resultobj;
51761 fail:
51762 return NULL;
51763 }
51764
51765
51766 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51767 PyObject *obj;
51768 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51769 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51770 return SWIG_Py_Void();
51771 }
51772
51773 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51774 return SWIG_Python_InitShadowInstance(args);
51775 }
51776
51777 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51778 PyObject *resultobj = 0;
51779 int arg1 = (int) 1 ;
51780 int arg2 = (int) 0 ;
51781 int arg3 = (int) 0 ;
51782 int arg4 = (int) 0 ;
51783 wxFlexGridSizer *result = 0 ;
51784 int val1 ;
51785 int ecode1 = 0 ;
51786 int val2 ;
51787 int ecode2 = 0 ;
51788 int val3 ;
51789 int ecode3 = 0 ;
51790 int val4 ;
51791 int ecode4 = 0 ;
51792 PyObject * obj0 = 0 ;
51793 PyObject * obj1 = 0 ;
51794 PyObject * obj2 = 0 ;
51795 PyObject * obj3 = 0 ;
51796 char * kwnames[] = {
51797 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51798 };
51799
51800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51801 if (obj0) {
51802 ecode1 = SWIG_AsVal_int(obj0, &val1);
51803 if (!SWIG_IsOK(ecode1)) {
51804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51805 }
51806 arg1 = static_cast< int >(val1);
51807 }
51808 if (obj1) {
51809 ecode2 = SWIG_AsVal_int(obj1, &val2);
51810 if (!SWIG_IsOK(ecode2)) {
51811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51812 }
51813 arg2 = static_cast< int >(val2);
51814 }
51815 if (obj2) {
51816 ecode3 = SWIG_AsVal_int(obj2, &val3);
51817 if (!SWIG_IsOK(ecode3)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51819 }
51820 arg3 = static_cast< int >(val3);
51821 }
51822 if (obj3) {
51823 ecode4 = SWIG_AsVal_int(obj3, &val4);
51824 if (!SWIG_IsOK(ecode4)) {
51825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51826 }
51827 arg4 = static_cast< int >(val4);
51828 }
51829 {
51830 PyThreadState* __tstate = wxPyBeginAllowThreads();
51831 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51832 wxPyEndAllowThreads(__tstate);
51833 if (PyErr_Occurred()) SWIG_fail;
51834 }
51835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51836 return resultobj;
51837 fail:
51838 return NULL;
51839 }
51840
51841
51842 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51843 PyObject *resultobj = 0;
51844 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51845 size_t arg2 ;
51846 int arg3 = (int) 0 ;
51847 void *argp1 = 0 ;
51848 int res1 = 0 ;
51849 size_t val2 ;
51850 int ecode2 = 0 ;
51851 int val3 ;
51852 int ecode3 = 0 ;
51853 PyObject * obj0 = 0 ;
51854 PyObject * obj1 = 0 ;
51855 PyObject * obj2 = 0 ;
51856 char * kwnames[] = {
51857 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51858 };
51859
51860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51862 if (!SWIG_IsOK(res1)) {
51863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51864 }
51865 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51866 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51867 if (!SWIG_IsOK(ecode2)) {
51868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51869 }
51870 arg2 = static_cast< size_t >(val2);
51871 if (obj2) {
51872 ecode3 = SWIG_AsVal_int(obj2, &val3);
51873 if (!SWIG_IsOK(ecode3)) {
51874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51875 }
51876 arg3 = static_cast< int >(val3);
51877 }
51878 {
51879 PyThreadState* __tstate = wxPyBeginAllowThreads();
51880 (arg1)->AddGrowableRow(arg2,arg3);
51881 wxPyEndAllowThreads(__tstate);
51882 if (PyErr_Occurred()) SWIG_fail;
51883 }
51884 resultobj = SWIG_Py_Void();
51885 return resultobj;
51886 fail:
51887 return NULL;
51888 }
51889
51890
51891 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51892 PyObject *resultobj = 0;
51893 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51894 size_t arg2 ;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 size_t val2 ;
51898 int ecode2 = 0 ;
51899 PyObject * obj0 = 0 ;
51900 PyObject * obj1 = 0 ;
51901 char * kwnames[] = {
51902 (char *) "self",(char *) "idx", NULL
51903 };
51904
51905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51907 if (!SWIG_IsOK(res1)) {
51908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51909 }
51910 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51911 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51912 if (!SWIG_IsOK(ecode2)) {
51913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51914 }
51915 arg2 = static_cast< size_t >(val2);
51916 {
51917 PyThreadState* __tstate = wxPyBeginAllowThreads();
51918 (arg1)->RemoveGrowableRow(arg2);
51919 wxPyEndAllowThreads(__tstate);
51920 if (PyErr_Occurred()) SWIG_fail;
51921 }
51922 resultobj = SWIG_Py_Void();
51923 return resultobj;
51924 fail:
51925 return NULL;
51926 }
51927
51928
51929 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51930 PyObject *resultobj = 0;
51931 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51932 size_t arg2 ;
51933 int arg3 = (int) 0 ;
51934 void *argp1 = 0 ;
51935 int res1 = 0 ;
51936 size_t val2 ;
51937 int ecode2 = 0 ;
51938 int val3 ;
51939 int ecode3 = 0 ;
51940 PyObject * obj0 = 0 ;
51941 PyObject * obj1 = 0 ;
51942 PyObject * obj2 = 0 ;
51943 char * kwnames[] = {
51944 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51945 };
51946
51947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51949 if (!SWIG_IsOK(res1)) {
51950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51951 }
51952 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51953 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51954 if (!SWIG_IsOK(ecode2)) {
51955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51956 }
51957 arg2 = static_cast< size_t >(val2);
51958 if (obj2) {
51959 ecode3 = SWIG_AsVal_int(obj2, &val3);
51960 if (!SWIG_IsOK(ecode3)) {
51961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51962 }
51963 arg3 = static_cast< int >(val3);
51964 }
51965 {
51966 PyThreadState* __tstate = wxPyBeginAllowThreads();
51967 (arg1)->AddGrowableCol(arg2,arg3);
51968 wxPyEndAllowThreads(__tstate);
51969 if (PyErr_Occurred()) SWIG_fail;
51970 }
51971 resultobj = SWIG_Py_Void();
51972 return resultobj;
51973 fail:
51974 return NULL;
51975 }
51976
51977
51978 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51979 PyObject *resultobj = 0;
51980 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51981 size_t arg2 ;
51982 void *argp1 = 0 ;
51983 int res1 = 0 ;
51984 size_t val2 ;
51985 int ecode2 = 0 ;
51986 PyObject * obj0 = 0 ;
51987 PyObject * obj1 = 0 ;
51988 char * kwnames[] = {
51989 (char *) "self",(char *) "idx", NULL
51990 };
51991
51992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51994 if (!SWIG_IsOK(res1)) {
51995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51996 }
51997 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51998 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51999 if (!SWIG_IsOK(ecode2)) {
52000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52001 }
52002 arg2 = static_cast< size_t >(val2);
52003 {
52004 PyThreadState* __tstate = wxPyBeginAllowThreads();
52005 (arg1)->RemoveGrowableCol(arg2);
52006 wxPyEndAllowThreads(__tstate);
52007 if (PyErr_Occurred()) SWIG_fail;
52008 }
52009 resultobj = SWIG_Py_Void();
52010 return resultobj;
52011 fail:
52012 return NULL;
52013 }
52014
52015
52016 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52017 PyObject *resultobj = 0;
52018 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52019 int arg2 ;
52020 void *argp1 = 0 ;
52021 int res1 = 0 ;
52022 int val2 ;
52023 int ecode2 = 0 ;
52024 PyObject * obj0 = 0 ;
52025 PyObject * obj1 = 0 ;
52026 char * kwnames[] = {
52027 (char *) "self",(char *) "direction", NULL
52028 };
52029
52030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52032 if (!SWIG_IsOK(res1)) {
52033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52034 }
52035 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52036 ecode2 = SWIG_AsVal_int(obj1, &val2);
52037 if (!SWIG_IsOK(ecode2)) {
52038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52039 }
52040 arg2 = static_cast< int >(val2);
52041 {
52042 PyThreadState* __tstate = wxPyBeginAllowThreads();
52043 (arg1)->SetFlexibleDirection(arg2);
52044 wxPyEndAllowThreads(__tstate);
52045 if (PyErr_Occurred()) SWIG_fail;
52046 }
52047 resultobj = SWIG_Py_Void();
52048 return resultobj;
52049 fail:
52050 return NULL;
52051 }
52052
52053
52054 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52055 PyObject *resultobj = 0;
52056 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52057 int result;
52058 void *argp1 = 0 ;
52059 int res1 = 0 ;
52060 PyObject *swig_obj[1] ;
52061
52062 if (!args) SWIG_fail;
52063 swig_obj[0] = args;
52064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52065 if (!SWIG_IsOK(res1)) {
52066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52067 }
52068 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52069 {
52070 PyThreadState* __tstate = wxPyBeginAllowThreads();
52071 result = (int)(arg1)->GetFlexibleDirection();
52072 wxPyEndAllowThreads(__tstate);
52073 if (PyErr_Occurred()) SWIG_fail;
52074 }
52075 resultobj = SWIG_From_int(static_cast< int >(result));
52076 return resultobj;
52077 fail:
52078 return NULL;
52079 }
52080
52081
52082 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52083 PyObject *resultobj = 0;
52084 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52085 wxFlexSizerGrowMode arg2 ;
52086 void *argp1 = 0 ;
52087 int res1 = 0 ;
52088 int val2 ;
52089 int ecode2 = 0 ;
52090 PyObject * obj0 = 0 ;
52091 PyObject * obj1 = 0 ;
52092 char * kwnames[] = {
52093 (char *) "self",(char *) "mode", NULL
52094 };
52095
52096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52098 if (!SWIG_IsOK(res1)) {
52099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52100 }
52101 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52102 ecode2 = SWIG_AsVal_int(obj1, &val2);
52103 if (!SWIG_IsOK(ecode2)) {
52104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52105 }
52106 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52107 {
52108 PyThreadState* __tstate = wxPyBeginAllowThreads();
52109 (arg1)->SetNonFlexibleGrowMode(arg2);
52110 wxPyEndAllowThreads(__tstate);
52111 if (PyErr_Occurred()) SWIG_fail;
52112 }
52113 resultobj = SWIG_Py_Void();
52114 return resultobj;
52115 fail:
52116 return NULL;
52117 }
52118
52119
52120 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52121 PyObject *resultobj = 0;
52122 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52123 wxFlexSizerGrowMode result;
52124 void *argp1 = 0 ;
52125 int res1 = 0 ;
52126 PyObject *swig_obj[1] ;
52127
52128 if (!args) SWIG_fail;
52129 swig_obj[0] = args;
52130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52131 if (!SWIG_IsOK(res1)) {
52132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52133 }
52134 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52135 {
52136 PyThreadState* __tstate = wxPyBeginAllowThreads();
52137 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52138 wxPyEndAllowThreads(__tstate);
52139 if (PyErr_Occurred()) SWIG_fail;
52140 }
52141 resultobj = SWIG_From_int(static_cast< int >(result));
52142 return resultobj;
52143 fail:
52144 return NULL;
52145 }
52146
52147
52148 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52149 PyObject *resultobj = 0;
52150 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52151 wxArrayInt *result = 0 ;
52152 void *argp1 = 0 ;
52153 int res1 = 0 ;
52154 PyObject *swig_obj[1] ;
52155
52156 if (!args) SWIG_fail;
52157 swig_obj[0] = args;
52158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52159 if (!SWIG_IsOK(res1)) {
52160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52161 }
52162 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52163 {
52164 PyThreadState* __tstate = wxPyBeginAllowThreads();
52165 {
52166 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52167 result = (wxArrayInt *) &_result_ref;
52168 }
52169 wxPyEndAllowThreads(__tstate);
52170 if (PyErr_Occurred()) SWIG_fail;
52171 }
52172 {
52173 resultobj = wxArrayInt2PyList_helper(*result);
52174 }
52175 return resultobj;
52176 fail:
52177 return NULL;
52178 }
52179
52180
52181 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52182 PyObject *resultobj = 0;
52183 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52184 wxArrayInt *result = 0 ;
52185 void *argp1 = 0 ;
52186 int res1 = 0 ;
52187 PyObject *swig_obj[1] ;
52188
52189 if (!args) SWIG_fail;
52190 swig_obj[0] = args;
52191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52192 if (!SWIG_IsOK(res1)) {
52193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52194 }
52195 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52196 {
52197 PyThreadState* __tstate = wxPyBeginAllowThreads();
52198 {
52199 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52200 result = (wxArrayInt *) &_result_ref;
52201 }
52202 wxPyEndAllowThreads(__tstate);
52203 if (PyErr_Occurred()) SWIG_fail;
52204 }
52205 {
52206 resultobj = wxArrayInt2PyList_helper(*result);
52207 }
52208 return resultobj;
52209 fail:
52210 return NULL;
52211 }
52212
52213
52214 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52215 PyObject *obj;
52216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52217 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52218 return SWIG_Py_Void();
52219 }
52220
52221 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52222 return SWIG_Python_InitShadowInstance(args);
52223 }
52224
52225 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52226 PyObject *resultobj = 0;
52227 wxStdDialogButtonSizer *result = 0 ;
52228
52229 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52230 {
52231 PyThreadState* __tstate = wxPyBeginAllowThreads();
52232 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52233 wxPyEndAllowThreads(__tstate);
52234 if (PyErr_Occurred()) SWIG_fail;
52235 }
52236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52237 return resultobj;
52238 fail:
52239 return NULL;
52240 }
52241
52242
52243 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52244 PyObject *resultobj = 0;
52245 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52246 wxButton *arg2 = (wxButton *) 0 ;
52247 void *argp1 = 0 ;
52248 int res1 = 0 ;
52249 void *argp2 = 0 ;
52250 int res2 = 0 ;
52251 PyObject * obj0 = 0 ;
52252 PyObject * obj1 = 0 ;
52253 char * kwnames[] = {
52254 (char *) "self",(char *) "button", NULL
52255 };
52256
52257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52259 if (!SWIG_IsOK(res1)) {
52260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52261 }
52262 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52264 if (!SWIG_IsOK(res2)) {
52265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52266 }
52267 arg2 = reinterpret_cast< wxButton * >(argp2);
52268 {
52269 PyThreadState* __tstate = wxPyBeginAllowThreads();
52270 (arg1)->AddButton(arg2);
52271 wxPyEndAllowThreads(__tstate);
52272 if (PyErr_Occurred()) SWIG_fail;
52273 }
52274 resultobj = SWIG_Py_Void();
52275 return resultobj;
52276 fail:
52277 return NULL;
52278 }
52279
52280
52281 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52282 PyObject *resultobj = 0;
52283 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52284 void *argp1 = 0 ;
52285 int res1 = 0 ;
52286 PyObject *swig_obj[1] ;
52287
52288 if (!args) SWIG_fail;
52289 swig_obj[0] = args;
52290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52291 if (!SWIG_IsOK(res1)) {
52292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52293 }
52294 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52295 {
52296 PyThreadState* __tstate = wxPyBeginAllowThreads();
52297 (arg1)->Realize();
52298 wxPyEndAllowThreads(__tstate);
52299 if (PyErr_Occurred()) SWIG_fail;
52300 }
52301 resultobj = SWIG_Py_Void();
52302 return resultobj;
52303 fail:
52304 return NULL;
52305 }
52306
52307
52308 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52309 PyObject *resultobj = 0;
52310 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52311 wxButton *arg2 = (wxButton *) 0 ;
52312 void *argp1 = 0 ;
52313 int res1 = 0 ;
52314 void *argp2 = 0 ;
52315 int res2 = 0 ;
52316 PyObject * obj0 = 0 ;
52317 PyObject * obj1 = 0 ;
52318 char * kwnames[] = {
52319 (char *) "self",(char *) "button", NULL
52320 };
52321
52322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52324 if (!SWIG_IsOK(res1)) {
52325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52326 }
52327 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52329 if (!SWIG_IsOK(res2)) {
52330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52331 }
52332 arg2 = reinterpret_cast< wxButton * >(argp2);
52333 {
52334 PyThreadState* __tstate = wxPyBeginAllowThreads();
52335 (arg1)->SetAffirmativeButton(arg2);
52336 wxPyEndAllowThreads(__tstate);
52337 if (PyErr_Occurred()) SWIG_fail;
52338 }
52339 resultobj = SWIG_Py_Void();
52340 return resultobj;
52341 fail:
52342 return NULL;
52343 }
52344
52345
52346 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52347 PyObject *resultobj = 0;
52348 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52349 wxButton *arg2 = (wxButton *) 0 ;
52350 void *argp1 = 0 ;
52351 int res1 = 0 ;
52352 void *argp2 = 0 ;
52353 int res2 = 0 ;
52354 PyObject * obj0 = 0 ;
52355 PyObject * obj1 = 0 ;
52356 char * kwnames[] = {
52357 (char *) "self",(char *) "button", NULL
52358 };
52359
52360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52362 if (!SWIG_IsOK(res1)) {
52363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52364 }
52365 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52367 if (!SWIG_IsOK(res2)) {
52368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52369 }
52370 arg2 = reinterpret_cast< wxButton * >(argp2);
52371 {
52372 PyThreadState* __tstate = wxPyBeginAllowThreads();
52373 (arg1)->SetNegativeButton(arg2);
52374 wxPyEndAllowThreads(__tstate);
52375 if (PyErr_Occurred()) SWIG_fail;
52376 }
52377 resultobj = SWIG_Py_Void();
52378 return resultobj;
52379 fail:
52380 return NULL;
52381 }
52382
52383
52384 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52385 PyObject *resultobj = 0;
52386 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52387 wxButton *arg2 = (wxButton *) 0 ;
52388 void *argp1 = 0 ;
52389 int res1 = 0 ;
52390 void *argp2 = 0 ;
52391 int res2 = 0 ;
52392 PyObject * obj0 = 0 ;
52393 PyObject * obj1 = 0 ;
52394 char * kwnames[] = {
52395 (char *) "self",(char *) "button", NULL
52396 };
52397
52398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52400 if (!SWIG_IsOK(res1)) {
52401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52402 }
52403 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52404 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52405 if (!SWIG_IsOK(res2)) {
52406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52407 }
52408 arg2 = reinterpret_cast< wxButton * >(argp2);
52409 {
52410 PyThreadState* __tstate = wxPyBeginAllowThreads();
52411 (arg1)->SetCancelButton(arg2);
52412 wxPyEndAllowThreads(__tstate);
52413 if (PyErr_Occurred()) SWIG_fail;
52414 }
52415 resultobj = SWIG_Py_Void();
52416 return resultobj;
52417 fail:
52418 return NULL;
52419 }
52420
52421
52422 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52423 PyObject *resultobj = 0;
52424 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52425 wxButton *result = 0 ;
52426 void *argp1 = 0 ;
52427 int res1 = 0 ;
52428 PyObject *swig_obj[1] ;
52429
52430 if (!args) SWIG_fail;
52431 swig_obj[0] = args;
52432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52433 if (!SWIG_IsOK(res1)) {
52434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52435 }
52436 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52437 {
52438 PyThreadState* __tstate = wxPyBeginAllowThreads();
52439 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52440 wxPyEndAllowThreads(__tstate);
52441 if (PyErr_Occurred()) SWIG_fail;
52442 }
52443 {
52444 resultobj = wxPyMake_wxObject(result, (bool)0);
52445 }
52446 return resultobj;
52447 fail:
52448 return NULL;
52449 }
52450
52451
52452 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52453 PyObject *resultobj = 0;
52454 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52455 wxButton *result = 0 ;
52456 void *argp1 = 0 ;
52457 int res1 = 0 ;
52458 PyObject *swig_obj[1] ;
52459
52460 if (!args) SWIG_fail;
52461 swig_obj[0] = args;
52462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52463 if (!SWIG_IsOK(res1)) {
52464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52465 }
52466 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52467 {
52468 PyThreadState* __tstate = wxPyBeginAllowThreads();
52469 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52470 wxPyEndAllowThreads(__tstate);
52471 if (PyErr_Occurred()) SWIG_fail;
52472 }
52473 {
52474 resultobj = wxPyMake_wxObject(result, (bool)0);
52475 }
52476 return resultobj;
52477 fail:
52478 return NULL;
52479 }
52480
52481
52482 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52483 PyObject *resultobj = 0;
52484 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52485 wxButton *result = 0 ;
52486 void *argp1 = 0 ;
52487 int res1 = 0 ;
52488 PyObject *swig_obj[1] ;
52489
52490 if (!args) SWIG_fail;
52491 swig_obj[0] = args;
52492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52495 }
52496 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52497 {
52498 PyThreadState* __tstate = wxPyBeginAllowThreads();
52499 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52500 wxPyEndAllowThreads(__tstate);
52501 if (PyErr_Occurred()) SWIG_fail;
52502 }
52503 {
52504 resultobj = wxPyMake_wxObject(result, (bool)0);
52505 }
52506 return resultobj;
52507 fail:
52508 return NULL;
52509 }
52510
52511
52512 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52513 PyObject *resultobj = 0;
52514 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52515 wxButton *result = 0 ;
52516 void *argp1 = 0 ;
52517 int res1 = 0 ;
52518 PyObject *swig_obj[1] ;
52519
52520 if (!args) SWIG_fail;
52521 swig_obj[0] = args;
52522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52523 if (!SWIG_IsOK(res1)) {
52524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52525 }
52526 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52527 {
52528 PyThreadState* __tstate = wxPyBeginAllowThreads();
52529 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52530 wxPyEndAllowThreads(__tstate);
52531 if (PyErr_Occurred()) SWIG_fail;
52532 }
52533 {
52534 resultobj = wxPyMake_wxObject(result, (bool)0);
52535 }
52536 return resultobj;
52537 fail:
52538 return NULL;
52539 }
52540
52541
52542 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52543 PyObject *resultobj = 0;
52544 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52545 wxButton *result = 0 ;
52546 void *argp1 = 0 ;
52547 int res1 = 0 ;
52548 PyObject *swig_obj[1] ;
52549
52550 if (!args) SWIG_fail;
52551 swig_obj[0] = args;
52552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52555 }
52556 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52557 {
52558 PyThreadState* __tstate = wxPyBeginAllowThreads();
52559 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52560 wxPyEndAllowThreads(__tstate);
52561 if (PyErr_Occurred()) SWIG_fail;
52562 }
52563 {
52564 resultobj = wxPyMake_wxObject(result, (bool)0);
52565 }
52566 return resultobj;
52567 fail:
52568 return NULL;
52569 }
52570
52571
52572 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52573 PyObject *obj;
52574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52575 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52576 return SWIG_Py_Void();
52577 }
52578
52579 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52580 return SWIG_Python_InitShadowInstance(args);
52581 }
52582
52583 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52584 PyObject *resultobj = 0;
52585 int arg1 = (int) 0 ;
52586 int arg2 = (int) 0 ;
52587 wxGBPosition *result = 0 ;
52588 int val1 ;
52589 int ecode1 = 0 ;
52590 int val2 ;
52591 int ecode2 = 0 ;
52592 PyObject * obj0 = 0 ;
52593 PyObject * obj1 = 0 ;
52594 char * kwnames[] = {
52595 (char *) "row",(char *) "col", NULL
52596 };
52597
52598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52599 if (obj0) {
52600 ecode1 = SWIG_AsVal_int(obj0, &val1);
52601 if (!SWIG_IsOK(ecode1)) {
52602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52603 }
52604 arg1 = static_cast< int >(val1);
52605 }
52606 if (obj1) {
52607 ecode2 = SWIG_AsVal_int(obj1, &val2);
52608 if (!SWIG_IsOK(ecode2)) {
52609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52610 }
52611 arg2 = static_cast< int >(val2);
52612 }
52613 {
52614 PyThreadState* __tstate = wxPyBeginAllowThreads();
52615 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52616 wxPyEndAllowThreads(__tstate);
52617 if (PyErr_Occurred()) SWIG_fail;
52618 }
52619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52620 return resultobj;
52621 fail:
52622 return NULL;
52623 }
52624
52625
52626 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52627 PyObject *resultobj = 0;
52628 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52629 void *argp1 = 0 ;
52630 int res1 = 0 ;
52631 PyObject *swig_obj[1] ;
52632
52633 if (!args) SWIG_fail;
52634 swig_obj[0] = args;
52635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52636 if (!SWIG_IsOK(res1)) {
52637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52638 }
52639 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52640 {
52641 PyThreadState* __tstate = wxPyBeginAllowThreads();
52642 delete arg1;
52643
52644 wxPyEndAllowThreads(__tstate);
52645 if (PyErr_Occurred()) SWIG_fail;
52646 }
52647 resultobj = SWIG_Py_Void();
52648 return resultobj;
52649 fail:
52650 return NULL;
52651 }
52652
52653
52654 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52655 PyObject *resultobj = 0;
52656 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52657 int result;
52658 void *argp1 = 0 ;
52659 int res1 = 0 ;
52660 PyObject *swig_obj[1] ;
52661
52662 if (!args) SWIG_fail;
52663 swig_obj[0] = args;
52664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52665 if (!SWIG_IsOK(res1)) {
52666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52667 }
52668 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52669 {
52670 PyThreadState* __tstate = wxPyBeginAllowThreads();
52671 result = (int)((wxGBPosition const *)arg1)->GetRow();
52672 wxPyEndAllowThreads(__tstate);
52673 if (PyErr_Occurred()) SWIG_fail;
52674 }
52675 resultobj = SWIG_From_int(static_cast< int >(result));
52676 return resultobj;
52677 fail:
52678 return NULL;
52679 }
52680
52681
52682 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52683 PyObject *resultobj = 0;
52684 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52685 int result;
52686 void *argp1 = 0 ;
52687 int res1 = 0 ;
52688 PyObject *swig_obj[1] ;
52689
52690 if (!args) SWIG_fail;
52691 swig_obj[0] = args;
52692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52693 if (!SWIG_IsOK(res1)) {
52694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52695 }
52696 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52697 {
52698 PyThreadState* __tstate = wxPyBeginAllowThreads();
52699 result = (int)((wxGBPosition const *)arg1)->GetCol();
52700 wxPyEndAllowThreads(__tstate);
52701 if (PyErr_Occurred()) SWIG_fail;
52702 }
52703 resultobj = SWIG_From_int(static_cast< int >(result));
52704 return resultobj;
52705 fail:
52706 return NULL;
52707 }
52708
52709
52710 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52711 PyObject *resultobj = 0;
52712 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52713 int arg2 ;
52714 void *argp1 = 0 ;
52715 int res1 = 0 ;
52716 int val2 ;
52717 int ecode2 = 0 ;
52718 PyObject * obj0 = 0 ;
52719 PyObject * obj1 = 0 ;
52720 char * kwnames[] = {
52721 (char *) "self",(char *) "row", NULL
52722 };
52723
52724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52726 if (!SWIG_IsOK(res1)) {
52727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52728 }
52729 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52730 ecode2 = SWIG_AsVal_int(obj1, &val2);
52731 if (!SWIG_IsOK(ecode2)) {
52732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52733 }
52734 arg2 = static_cast< int >(val2);
52735 {
52736 PyThreadState* __tstate = wxPyBeginAllowThreads();
52737 (arg1)->SetRow(arg2);
52738 wxPyEndAllowThreads(__tstate);
52739 if (PyErr_Occurred()) SWIG_fail;
52740 }
52741 resultobj = SWIG_Py_Void();
52742 return resultobj;
52743 fail:
52744 return NULL;
52745 }
52746
52747
52748 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52749 PyObject *resultobj = 0;
52750 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52751 int arg2 ;
52752 void *argp1 = 0 ;
52753 int res1 = 0 ;
52754 int val2 ;
52755 int ecode2 = 0 ;
52756 PyObject * obj0 = 0 ;
52757 PyObject * obj1 = 0 ;
52758 char * kwnames[] = {
52759 (char *) "self",(char *) "col", NULL
52760 };
52761
52762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52764 if (!SWIG_IsOK(res1)) {
52765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52766 }
52767 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52768 ecode2 = SWIG_AsVal_int(obj1, &val2);
52769 if (!SWIG_IsOK(ecode2)) {
52770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52771 }
52772 arg2 = static_cast< int >(val2);
52773 {
52774 PyThreadState* __tstate = wxPyBeginAllowThreads();
52775 (arg1)->SetCol(arg2);
52776 wxPyEndAllowThreads(__tstate);
52777 if (PyErr_Occurred()) SWIG_fail;
52778 }
52779 resultobj = SWIG_Py_Void();
52780 return resultobj;
52781 fail:
52782 return NULL;
52783 }
52784
52785
52786 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52787 PyObject *resultobj = 0;
52788 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52789 PyObject *arg2 = (PyObject *) 0 ;
52790 bool result;
52791 void *argp1 = 0 ;
52792 int res1 = 0 ;
52793 PyObject * obj0 = 0 ;
52794 PyObject * obj1 = 0 ;
52795 char * kwnames[] = {
52796 (char *) "self",(char *) "other", NULL
52797 };
52798
52799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52801 if (!SWIG_IsOK(res1)) {
52802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52803 }
52804 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52805 arg2 = obj1;
52806 {
52807 result = (bool)wxGBPosition___eq__(arg1,arg2);
52808 if (PyErr_Occurred()) SWIG_fail;
52809 }
52810 {
52811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52812 }
52813 return resultobj;
52814 fail:
52815 return NULL;
52816 }
52817
52818
52819 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52820 PyObject *resultobj = 0;
52821 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52822 PyObject *arg2 = (PyObject *) 0 ;
52823 bool result;
52824 void *argp1 = 0 ;
52825 int res1 = 0 ;
52826 PyObject * obj0 = 0 ;
52827 PyObject * obj1 = 0 ;
52828 char * kwnames[] = {
52829 (char *) "self",(char *) "other", NULL
52830 };
52831
52832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52834 if (!SWIG_IsOK(res1)) {
52835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52836 }
52837 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52838 arg2 = obj1;
52839 {
52840 result = (bool)wxGBPosition___ne__(arg1,arg2);
52841 if (PyErr_Occurred()) SWIG_fail;
52842 }
52843 {
52844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52845 }
52846 return resultobj;
52847 fail:
52848 return NULL;
52849 }
52850
52851
52852 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52853 PyObject *resultobj = 0;
52854 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52855 int arg2 = (int) 0 ;
52856 int arg3 = (int) 0 ;
52857 void *argp1 = 0 ;
52858 int res1 = 0 ;
52859 int val2 ;
52860 int ecode2 = 0 ;
52861 int val3 ;
52862 int ecode3 = 0 ;
52863 PyObject * obj0 = 0 ;
52864 PyObject * obj1 = 0 ;
52865 PyObject * obj2 = 0 ;
52866 char * kwnames[] = {
52867 (char *) "self",(char *) "row",(char *) "col", NULL
52868 };
52869
52870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52872 if (!SWIG_IsOK(res1)) {
52873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52874 }
52875 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52876 if (obj1) {
52877 ecode2 = SWIG_AsVal_int(obj1, &val2);
52878 if (!SWIG_IsOK(ecode2)) {
52879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52880 }
52881 arg2 = static_cast< int >(val2);
52882 }
52883 if (obj2) {
52884 ecode3 = SWIG_AsVal_int(obj2, &val3);
52885 if (!SWIG_IsOK(ecode3)) {
52886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52887 }
52888 arg3 = static_cast< int >(val3);
52889 }
52890 {
52891 PyThreadState* __tstate = wxPyBeginAllowThreads();
52892 wxGBPosition_Set(arg1,arg2,arg3);
52893 wxPyEndAllowThreads(__tstate);
52894 if (PyErr_Occurred()) SWIG_fail;
52895 }
52896 resultobj = SWIG_Py_Void();
52897 return resultobj;
52898 fail:
52899 return NULL;
52900 }
52901
52902
52903 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52904 PyObject *resultobj = 0;
52905 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52906 PyObject *result = 0 ;
52907 void *argp1 = 0 ;
52908 int res1 = 0 ;
52909 PyObject *swig_obj[1] ;
52910
52911 if (!args) SWIG_fail;
52912 swig_obj[0] = args;
52913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52914 if (!SWIG_IsOK(res1)) {
52915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52916 }
52917 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52918 {
52919 PyThreadState* __tstate = wxPyBeginAllowThreads();
52920 result = (PyObject *)wxGBPosition_Get(arg1);
52921 wxPyEndAllowThreads(__tstate);
52922 if (PyErr_Occurred()) SWIG_fail;
52923 }
52924 resultobj = result;
52925 return resultobj;
52926 fail:
52927 return NULL;
52928 }
52929
52930
52931 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52932 PyObject *obj;
52933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52934 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52935 return SWIG_Py_Void();
52936 }
52937
52938 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52939 return SWIG_Python_InitShadowInstance(args);
52940 }
52941
52942 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52943 PyObject *resultobj = 0;
52944 int arg1 = (int) 1 ;
52945 int arg2 = (int) 1 ;
52946 wxGBSpan *result = 0 ;
52947 int val1 ;
52948 int ecode1 = 0 ;
52949 int val2 ;
52950 int ecode2 = 0 ;
52951 PyObject * obj0 = 0 ;
52952 PyObject * obj1 = 0 ;
52953 char * kwnames[] = {
52954 (char *) "rowspan",(char *) "colspan", NULL
52955 };
52956
52957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52958 if (obj0) {
52959 ecode1 = SWIG_AsVal_int(obj0, &val1);
52960 if (!SWIG_IsOK(ecode1)) {
52961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52962 }
52963 arg1 = static_cast< int >(val1);
52964 }
52965 if (obj1) {
52966 ecode2 = SWIG_AsVal_int(obj1, &val2);
52967 if (!SWIG_IsOK(ecode2)) {
52968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52969 }
52970 arg2 = static_cast< int >(val2);
52971 }
52972 {
52973 PyThreadState* __tstate = wxPyBeginAllowThreads();
52974 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52975 wxPyEndAllowThreads(__tstate);
52976 if (PyErr_Occurred()) SWIG_fail;
52977 }
52978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52979 return resultobj;
52980 fail:
52981 return NULL;
52982 }
52983
52984
52985 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52986 PyObject *resultobj = 0;
52987 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52988 void *argp1 = 0 ;
52989 int res1 = 0 ;
52990 PyObject *swig_obj[1] ;
52991
52992 if (!args) SWIG_fail;
52993 swig_obj[0] = args;
52994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52995 if (!SWIG_IsOK(res1)) {
52996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52997 }
52998 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52999 {
53000 PyThreadState* __tstate = wxPyBeginAllowThreads();
53001 delete arg1;
53002
53003 wxPyEndAllowThreads(__tstate);
53004 if (PyErr_Occurred()) SWIG_fail;
53005 }
53006 resultobj = SWIG_Py_Void();
53007 return resultobj;
53008 fail:
53009 return NULL;
53010 }
53011
53012
53013 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53014 PyObject *resultobj = 0;
53015 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53016 int result;
53017 void *argp1 = 0 ;
53018 int res1 = 0 ;
53019 PyObject *swig_obj[1] ;
53020
53021 if (!args) SWIG_fail;
53022 swig_obj[0] = args;
53023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53024 if (!SWIG_IsOK(res1)) {
53025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53026 }
53027 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53028 {
53029 PyThreadState* __tstate = wxPyBeginAllowThreads();
53030 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53031 wxPyEndAllowThreads(__tstate);
53032 if (PyErr_Occurred()) SWIG_fail;
53033 }
53034 resultobj = SWIG_From_int(static_cast< int >(result));
53035 return resultobj;
53036 fail:
53037 return NULL;
53038 }
53039
53040
53041 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53042 PyObject *resultobj = 0;
53043 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53044 int result;
53045 void *argp1 = 0 ;
53046 int res1 = 0 ;
53047 PyObject *swig_obj[1] ;
53048
53049 if (!args) SWIG_fail;
53050 swig_obj[0] = args;
53051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53052 if (!SWIG_IsOK(res1)) {
53053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53054 }
53055 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53056 {
53057 PyThreadState* __tstate = wxPyBeginAllowThreads();
53058 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53059 wxPyEndAllowThreads(__tstate);
53060 if (PyErr_Occurred()) SWIG_fail;
53061 }
53062 resultobj = SWIG_From_int(static_cast< int >(result));
53063 return resultobj;
53064 fail:
53065 return NULL;
53066 }
53067
53068
53069 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53070 PyObject *resultobj = 0;
53071 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53072 int arg2 ;
53073 void *argp1 = 0 ;
53074 int res1 = 0 ;
53075 int val2 ;
53076 int ecode2 = 0 ;
53077 PyObject * obj0 = 0 ;
53078 PyObject * obj1 = 0 ;
53079 char * kwnames[] = {
53080 (char *) "self",(char *) "rowspan", NULL
53081 };
53082
53083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53085 if (!SWIG_IsOK(res1)) {
53086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53087 }
53088 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53089 ecode2 = SWIG_AsVal_int(obj1, &val2);
53090 if (!SWIG_IsOK(ecode2)) {
53091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53092 }
53093 arg2 = static_cast< int >(val2);
53094 {
53095 PyThreadState* __tstate = wxPyBeginAllowThreads();
53096 (arg1)->SetRowspan(arg2);
53097 wxPyEndAllowThreads(__tstate);
53098 if (PyErr_Occurred()) SWIG_fail;
53099 }
53100 resultobj = SWIG_Py_Void();
53101 return resultobj;
53102 fail:
53103 return NULL;
53104 }
53105
53106
53107 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53108 PyObject *resultobj = 0;
53109 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53110 int arg2 ;
53111 void *argp1 = 0 ;
53112 int res1 = 0 ;
53113 int val2 ;
53114 int ecode2 = 0 ;
53115 PyObject * obj0 = 0 ;
53116 PyObject * obj1 = 0 ;
53117 char * kwnames[] = {
53118 (char *) "self",(char *) "colspan", NULL
53119 };
53120
53121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53123 if (!SWIG_IsOK(res1)) {
53124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53125 }
53126 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53127 ecode2 = SWIG_AsVal_int(obj1, &val2);
53128 if (!SWIG_IsOK(ecode2)) {
53129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53130 }
53131 arg2 = static_cast< int >(val2);
53132 {
53133 PyThreadState* __tstate = wxPyBeginAllowThreads();
53134 (arg1)->SetColspan(arg2);
53135 wxPyEndAllowThreads(__tstate);
53136 if (PyErr_Occurred()) SWIG_fail;
53137 }
53138 resultobj = SWIG_Py_Void();
53139 return resultobj;
53140 fail:
53141 return NULL;
53142 }
53143
53144
53145 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53146 PyObject *resultobj = 0;
53147 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53148 PyObject *arg2 = (PyObject *) 0 ;
53149 bool result;
53150 void *argp1 = 0 ;
53151 int res1 = 0 ;
53152 PyObject * obj0 = 0 ;
53153 PyObject * obj1 = 0 ;
53154 char * kwnames[] = {
53155 (char *) "self",(char *) "other", NULL
53156 };
53157
53158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53160 if (!SWIG_IsOK(res1)) {
53161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53162 }
53163 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53164 arg2 = obj1;
53165 {
53166 result = (bool)wxGBSpan___eq__(arg1,arg2);
53167 if (PyErr_Occurred()) SWIG_fail;
53168 }
53169 {
53170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53171 }
53172 return resultobj;
53173 fail:
53174 return NULL;
53175 }
53176
53177
53178 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53179 PyObject *resultobj = 0;
53180 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53181 PyObject *arg2 = (PyObject *) 0 ;
53182 bool result;
53183 void *argp1 = 0 ;
53184 int res1 = 0 ;
53185 PyObject * obj0 = 0 ;
53186 PyObject * obj1 = 0 ;
53187 char * kwnames[] = {
53188 (char *) "self",(char *) "other", NULL
53189 };
53190
53191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53193 if (!SWIG_IsOK(res1)) {
53194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53195 }
53196 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53197 arg2 = obj1;
53198 {
53199 result = (bool)wxGBSpan___ne__(arg1,arg2);
53200 if (PyErr_Occurred()) SWIG_fail;
53201 }
53202 {
53203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53204 }
53205 return resultobj;
53206 fail:
53207 return NULL;
53208 }
53209
53210
53211 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53212 PyObject *resultobj = 0;
53213 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53214 int arg2 = (int) 1 ;
53215 int arg3 = (int) 1 ;
53216 void *argp1 = 0 ;
53217 int res1 = 0 ;
53218 int val2 ;
53219 int ecode2 = 0 ;
53220 int val3 ;
53221 int ecode3 = 0 ;
53222 PyObject * obj0 = 0 ;
53223 PyObject * obj1 = 0 ;
53224 PyObject * obj2 = 0 ;
53225 char * kwnames[] = {
53226 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53227 };
53228
53229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53231 if (!SWIG_IsOK(res1)) {
53232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53233 }
53234 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53235 if (obj1) {
53236 ecode2 = SWIG_AsVal_int(obj1, &val2);
53237 if (!SWIG_IsOK(ecode2)) {
53238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53239 }
53240 arg2 = static_cast< int >(val2);
53241 }
53242 if (obj2) {
53243 ecode3 = SWIG_AsVal_int(obj2, &val3);
53244 if (!SWIG_IsOK(ecode3)) {
53245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53246 }
53247 arg3 = static_cast< int >(val3);
53248 }
53249 {
53250 PyThreadState* __tstate = wxPyBeginAllowThreads();
53251 wxGBSpan_Set(arg1,arg2,arg3);
53252 wxPyEndAllowThreads(__tstate);
53253 if (PyErr_Occurred()) SWIG_fail;
53254 }
53255 resultobj = SWIG_Py_Void();
53256 return resultobj;
53257 fail:
53258 return NULL;
53259 }
53260
53261
53262 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53263 PyObject *resultobj = 0;
53264 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53265 PyObject *result = 0 ;
53266 void *argp1 = 0 ;
53267 int res1 = 0 ;
53268 PyObject *swig_obj[1] ;
53269
53270 if (!args) SWIG_fail;
53271 swig_obj[0] = args;
53272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53273 if (!SWIG_IsOK(res1)) {
53274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53275 }
53276 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53277 {
53278 PyThreadState* __tstate = wxPyBeginAllowThreads();
53279 result = (PyObject *)wxGBSpan_Get(arg1);
53280 wxPyEndAllowThreads(__tstate);
53281 if (PyErr_Occurred()) SWIG_fail;
53282 }
53283 resultobj = result;
53284 return resultobj;
53285 fail:
53286 return NULL;
53287 }
53288
53289
53290 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53291 PyObject *obj;
53292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53293 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53294 return SWIG_Py_Void();
53295 }
53296
53297 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53298 return SWIG_Python_InitShadowInstance(args);
53299 }
53300
53301 SWIGINTERN int DefaultSpan_set(PyObject *) {
53302 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53303 return 1;
53304 }
53305
53306
53307 SWIGINTERN PyObject *DefaultSpan_get(void) {
53308 PyObject *pyobj = 0;
53309
53310 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53311 return pyobj;
53312 }
53313
53314
53315 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53316 PyObject *resultobj = 0;
53317 wxGBSizerItem *result = 0 ;
53318
53319 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53320 {
53321 PyThreadState* __tstate = wxPyBeginAllowThreads();
53322 result = (wxGBSizerItem *)new wxGBSizerItem();
53323 wxPyEndAllowThreads(__tstate);
53324 if (PyErr_Occurred()) SWIG_fail;
53325 }
53326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53327 return resultobj;
53328 fail:
53329 return NULL;
53330 }
53331
53332
53333 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53334 PyObject *resultobj = 0;
53335 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53336 void *argp1 = 0 ;
53337 int res1 = 0 ;
53338 PyObject *swig_obj[1] ;
53339
53340 if (!args) SWIG_fail;
53341 swig_obj[0] = args;
53342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53343 if (!SWIG_IsOK(res1)) {
53344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53345 }
53346 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53347 {
53348 PyThreadState* __tstate = wxPyBeginAllowThreads();
53349 delete arg1;
53350
53351 wxPyEndAllowThreads(__tstate);
53352 if (PyErr_Occurred()) SWIG_fail;
53353 }
53354 resultobj = SWIG_Py_Void();
53355 return resultobj;
53356 fail:
53357 return NULL;
53358 }
53359
53360
53361 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53362 PyObject *resultobj = 0;
53363 wxWindow *arg1 = (wxWindow *) 0 ;
53364 wxGBPosition *arg2 = 0 ;
53365 wxGBSpan *arg3 = 0 ;
53366 int arg4 ;
53367 int arg5 ;
53368 PyObject *arg6 = (PyObject *) NULL ;
53369 wxGBSizerItem *result = 0 ;
53370 void *argp1 = 0 ;
53371 int res1 = 0 ;
53372 wxGBPosition temp2 ;
53373 wxGBSpan temp3 ;
53374 int val4 ;
53375 int ecode4 = 0 ;
53376 int val5 ;
53377 int ecode5 = 0 ;
53378 PyObject * obj0 = 0 ;
53379 PyObject * obj1 = 0 ;
53380 PyObject * obj2 = 0 ;
53381 PyObject * obj3 = 0 ;
53382 PyObject * obj4 = 0 ;
53383 PyObject * obj5 = 0 ;
53384 char * kwnames[] = {
53385 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53386 };
53387
53388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53390 if (!SWIG_IsOK(res1)) {
53391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53392 }
53393 arg1 = reinterpret_cast< wxWindow * >(argp1);
53394 {
53395 arg2 = &temp2;
53396 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53397 }
53398 {
53399 arg3 = &temp3;
53400 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53401 }
53402 ecode4 = SWIG_AsVal_int(obj3, &val4);
53403 if (!SWIG_IsOK(ecode4)) {
53404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53405 }
53406 arg4 = static_cast< int >(val4);
53407 ecode5 = SWIG_AsVal_int(obj4, &val5);
53408 if (!SWIG_IsOK(ecode5)) {
53409 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53410 }
53411 arg5 = static_cast< int >(val5);
53412 if (obj5) {
53413 arg6 = obj5;
53414 }
53415 {
53416 PyThreadState* __tstate = wxPyBeginAllowThreads();
53417 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53418 wxPyEndAllowThreads(__tstate);
53419 if (PyErr_Occurred()) SWIG_fail;
53420 }
53421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53422 return resultobj;
53423 fail:
53424 return NULL;
53425 }
53426
53427
53428 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53429 PyObject *resultobj = 0;
53430 wxSizer *arg1 = (wxSizer *) 0 ;
53431 wxGBPosition *arg2 = 0 ;
53432 wxGBSpan *arg3 = 0 ;
53433 int arg4 ;
53434 int arg5 ;
53435 PyObject *arg6 = (PyObject *) NULL ;
53436 wxGBSizerItem *result = 0 ;
53437 int res1 = 0 ;
53438 wxGBPosition temp2 ;
53439 wxGBSpan temp3 ;
53440 int val4 ;
53441 int ecode4 = 0 ;
53442 int val5 ;
53443 int ecode5 = 0 ;
53444 PyObject * obj0 = 0 ;
53445 PyObject * obj1 = 0 ;
53446 PyObject * obj2 = 0 ;
53447 PyObject * obj3 = 0 ;
53448 PyObject * obj4 = 0 ;
53449 PyObject * obj5 = 0 ;
53450 char * kwnames[] = {
53451 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53452 };
53453
53454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53455 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53456 if (!SWIG_IsOK(res1)) {
53457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53458 }
53459 {
53460 arg2 = &temp2;
53461 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53462 }
53463 {
53464 arg3 = &temp3;
53465 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53466 }
53467 ecode4 = SWIG_AsVal_int(obj3, &val4);
53468 if (!SWIG_IsOK(ecode4)) {
53469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53470 }
53471 arg4 = static_cast< int >(val4);
53472 ecode5 = SWIG_AsVal_int(obj4, &val5);
53473 if (!SWIG_IsOK(ecode5)) {
53474 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53475 }
53476 arg5 = static_cast< int >(val5);
53477 if (obj5) {
53478 arg6 = obj5;
53479 }
53480 {
53481 PyThreadState* __tstate = wxPyBeginAllowThreads();
53482 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53483 wxPyEndAllowThreads(__tstate);
53484 if (PyErr_Occurred()) SWIG_fail;
53485 }
53486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53487 return resultobj;
53488 fail:
53489 return NULL;
53490 }
53491
53492
53493 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53494 PyObject *resultobj = 0;
53495 int arg1 ;
53496 int arg2 ;
53497 wxGBPosition *arg3 = 0 ;
53498 wxGBSpan *arg4 = 0 ;
53499 int arg5 ;
53500 int arg6 ;
53501 PyObject *arg7 = (PyObject *) NULL ;
53502 wxGBSizerItem *result = 0 ;
53503 int val1 ;
53504 int ecode1 = 0 ;
53505 int val2 ;
53506 int ecode2 = 0 ;
53507 wxGBPosition temp3 ;
53508 wxGBSpan temp4 ;
53509 int val5 ;
53510 int ecode5 = 0 ;
53511 int val6 ;
53512 int ecode6 = 0 ;
53513 PyObject * obj0 = 0 ;
53514 PyObject * obj1 = 0 ;
53515 PyObject * obj2 = 0 ;
53516 PyObject * obj3 = 0 ;
53517 PyObject * obj4 = 0 ;
53518 PyObject * obj5 = 0 ;
53519 PyObject * obj6 = 0 ;
53520 char * kwnames[] = {
53521 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53522 };
53523
53524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53525 ecode1 = SWIG_AsVal_int(obj0, &val1);
53526 if (!SWIG_IsOK(ecode1)) {
53527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53528 }
53529 arg1 = static_cast< int >(val1);
53530 ecode2 = SWIG_AsVal_int(obj1, &val2);
53531 if (!SWIG_IsOK(ecode2)) {
53532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53533 }
53534 arg2 = static_cast< int >(val2);
53535 {
53536 arg3 = &temp3;
53537 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53538 }
53539 {
53540 arg4 = &temp4;
53541 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53542 }
53543 ecode5 = SWIG_AsVal_int(obj4, &val5);
53544 if (!SWIG_IsOK(ecode5)) {
53545 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53546 }
53547 arg5 = static_cast< int >(val5);
53548 ecode6 = SWIG_AsVal_int(obj5, &val6);
53549 if (!SWIG_IsOK(ecode6)) {
53550 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53551 }
53552 arg6 = static_cast< int >(val6);
53553 if (obj6) {
53554 arg7 = obj6;
53555 }
53556 {
53557 PyThreadState* __tstate = wxPyBeginAllowThreads();
53558 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53559 wxPyEndAllowThreads(__tstate);
53560 if (PyErr_Occurred()) SWIG_fail;
53561 }
53562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53563 return resultobj;
53564 fail:
53565 return NULL;
53566 }
53567
53568
53569 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53570 PyObject *resultobj = 0;
53571 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53572 wxGBPosition result;
53573 void *argp1 = 0 ;
53574 int res1 = 0 ;
53575 PyObject *swig_obj[1] ;
53576
53577 if (!args) SWIG_fail;
53578 swig_obj[0] = args;
53579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53580 if (!SWIG_IsOK(res1)) {
53581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53582 }
53583 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53584 {
53585 PyThreadState* __tstate = wxPyBeginAllowThreads();
53586 result = ((wxGBSizerItem const *)arg1)->GetPos();
53587 wxPyEndAllowThreads(__tstate);
53588 if (PyErr_Occurred()) SWIG_fail;
53589 }
53590 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53591 return resultobj;
53592 fail:
53593 return NULL;
53594 }
53595
53596
53597 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53598 PyObject *resultobj = 0;
53599 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53600 wxGBSpan result;
53601 void *argp1 = 0 ;
53602 int res1 = 0 ;
53603 PyObject *swig_obj[1] ;
53604
53605 if (!args) SWIG_fail;
53606 swig_obj[0] = args;
53607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53608 if (!SWIG_IsOK(res1)) {
53609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53610 }
53611 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53612 {
53613 PyThreadState* __tstate = wxPyBeginAllowThreads();
53614 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53615 wxPyEndAllowThreads(__tstate);
53616 if (PyErr_Occurred()) SWIG_fail;
53617 }
53618 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53619 return resultobj;
53620 fail:
53621 return NULL;
53622 }
53623
53624
53625 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53626 PyObject *resultobj = 0;
53627 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53628 wxGBPosition *arg2 = 0 ;
53629 bool result;
53630 void *argp1 = 0 ;
53631 int res1 = 0 ;
53632 wxGBPosition temp2 ;
53633 PyObject * obj0 = 0 ;
53634 PyObject * obj1 = 0 ;
53635 char * kwnames[] = {
53636 (char *) "self",(char *) "pos", NULL
53637 };
53638
53639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53641 if (!SWIG_IsOK(res1)) {
53642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53643 }
53644 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53645 {
53646 arg2 = &temp2;
53647 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53648 }
53649 {
53650 PyThreadState* __tstate = wxPyBeginAllowThreads();
53651 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53652 wxPyEndAllowThreads(__tstate);
53653 if (PyErr_Occurred()) SWIG_fail;
53654 }
53655 {
53656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53657 }
53658 return resultobj;
53659 fail:
53660 return NULL;
53661 }
53662
53663
53664 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53665 PyObject *resultobj = 0;
53666 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53667 wxGBSpan *arg2 = 0 ;
53668 bool result;
53669 void *argp1 = 0 ;
53670 int res1 = 0 ;
53671 wxGBSpan temp2 ;
53672 PyObject * obj0 = 0 ;
53673 PyObject * obj1 = 0 ;
53674 char * kwnames[] = {
53675 (char *) "self",(char *) "span", NULL
53676 };
53677
53678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53680 if (!SWIG_IsOK(res1)) {
53681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53682 }
53683 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53684 {
53685 arg2 = &temp2;
53686 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53687 }
53688 {
53689 PyThreadState* __tstate = wxPyBeginAllowThreads();
53690 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53691 wxPyEndAllowThreads(__tstate);
53692 if (PyErr_Occurred()) SWIG_fail;
53693 }
53694 {
53695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53696 }
53697 return resultobj;
53698 fail:
53699 return NULL;
53700 }
53701
53702
53703 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53704 PyObject *resultobj = 0;
53705 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53706 wxGBSizerItem *arg2 = 0 ;
53707 bool result;
53708 void *argp1 = 0 ;
53709 int res1 = 0 ;
53710 void *argp2 = 0 ;
53711 int res2 = 0 ;
53712 PyObject * obj0 = 0 ;
53713 PyObject * obj1 = 0 ;
53714 char * kwnames[] = {
53715 (char *) "self",(char *) "other", NULL
53716 };
53717
53718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53720 if (!SWIG_IsOK(res1)) {
53721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53722 }
53723 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53724 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53725 if (!SWIG_IsOK(res2)) {
53726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53727 }
53728 if (!argp2) {
53729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53730 }
53731 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53732 {
53733 PyThreadState* __tstate = wxPyBeginAllowThreads();
53734 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53735 wxPyEndAllowThreads(__tstate);
53736 if (PyErr_Occurred()) SWIG_fail;
53737 }
53738 {
53739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53740 }
53741 return resultobj;
53742 fail:
53743 return NULL;
53744 }
53745
53746
53747 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53748 PyObject *resultobj = 0;
53749 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53750 wxGBPosition *arg2 = 0 ;
53751 wxGBSpan *arg3 = 0 ;
53752 bool result;
53753 void *argp1 = 0 ;
53754 int res1 = 0 ;
53755 wxGBPosition temp2 ;
53756 wxGBSpan temp3 ;
53757 PyObject * obj0 = 0 ;
53758 PyObject * obj1 = 0 ;
53759 PyObject * obj2 = 0 ;
53760 char * kwnames[] = {
53761 (char *) "self",(char *) "pos",(char *) "span", NULL
53762 };
53763
53764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53766 if (!SWIG_IsOK(res1)) {
53767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53768 }
53769 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53770 {
53771 arg2 = &temp2;
53772 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53773 }
53774 {
53775 arg3 = &temp3;
53776 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53777 }
53778 {
53779 PyThreadState* __tstate = wxPyBeginAllowThreads();
53780 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53781 wxPyEndAllowThreads(__tstate);
53782 if (PyErr_Occurred()) SWIG_fail;
53783 }
53784 {
53785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53786 }
53787 return resultobj;
53788 fail:
53789 return NULL;
53790 }
53791
53792
53793 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53794 PyObject *resultobj = 0;
53795 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53796 wxGBPosition result;
53797 void *argp1 = 0 ;
53798 int res1 = 0 ;
53799 PyObject *swig_obj[1] ;
53800
53801 if (!args) SWIG_fail;
53802 swig_obj[0] = args;
53803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53804 if (!SWIG_IsOK(res1)) {
53805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53806 }
53807 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53808 {
53809 PyThreadState* __tstate = wxPyBeginAllowThreads();
53810 result = wxGBSizerItem_GetEndPos(arg1);
53811 wxPyEndAllowThreads(__tstate);
53812 if (PyErr_Occurred()) SWIG_fail;
53813 }
53814 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53815 return resultobj;
53816 fail:
53817 return NULL;
53818 }
53819
53820
53821 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53822 PyObject *resultobj = 0;
53823 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53824 wxGridBagSizer *result = 0 ;
53825 void *argp1 = 0 ;
53826 int res1 = 0 ;
53827 PyObject *swig_obj[1] ;
53828
53829 if (!args) SWIG_fail;
53830 swig_obj[0] = args;
53831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53832 if (!SWIG_IsOK(res1)) {
53833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53834 }
53835 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53836 {
53837 PyThreadState* __tstate = wxPyBeginAllowThreads();
53838 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53839 wxPyEndAllowThreads(__tstate);
53840 if (PyErr_Occurred()) SWIG_fail;
53841 }
53842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53843 return resultobj;
53844 fail:
53845 return NULL;
53846 }
53847
53848
53849 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53850 PyObject *resultobj = 0;
53851 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53852 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53853 void *argp1 = 0 ;
53854 int res1 = 0 ;
53855 void *argp2 = 0 ;
53856 int res2 = 0 ;
53857 PyObject * obj0 = 0 ;
53858 PyObject * obj1 = 0 ;
53859 char * kwnames[] = {
53860 (char *) "self",(char *) "sizer", NULL
53861 };
53862
53863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53865 if (!SWIG_IsOK(res1)) {
53866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53867 }
53868 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53870 if (!SWIG_IsOK(res2)) {
53871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53872 }
53873 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53874 {
53875 PyThreadState* __tstate = wxPyBeginAllowThreads();
53876 (arg1)->SetGBSizer(arg2);
53877 wxPyEndAllowThreads(__tstate);
53878 if (PyErr_Occurred()) SWIG_fail;
53879 }
53880 resultobj = SWIG_Py_Void();
53881 return resultobj;
53882 fail:
53883 return NULL;
53884 }
53885
53886
53887 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53888 PyObject *obj;
53889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53890 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53891 return SWIG_Py_Void();
53892 }
53893
53894 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53895 return SWIG_Python_InitShadowInstance(args);
53896 }
53897
53898 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53899 PyObject *resultobj = 0;
53900 int arg1 = (int) 0 ;
53901 int arg2 = (int) 0 ;
53902 wxGridBagSizer *result = 0 ;
53903 int val1 ;
53904 int ecode1 = 0 ;
53905 int val2 ;
53906 int ecode2 = 0 ;
53907 PyObject * obj0 = 0 ;
53908 PyObject * obj1 = 0 ;
53909 char * kwnames[] = {
53910 (char *) "vgap",(char *) "hgap", NULL
53911 };
53912
53913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53914 if (obj0) {
53915 ecode1 = SWIG_AsVal_int(obj0, &val1);
53916 if (!SWIG_IsOK(ecode1)) {
53917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53918 }
53919 arg1 = static_cast< int >(val1);
53920 }
53921 if (obj1) {
53922 ecode2 = SWIG_AsVal_int(obj1, &val2);
53923 if (!SWIG_IsOK(ecode2)) {
53924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53925 }
53926 arg2 = static_cast< int >(val2);
53927 }
53928 {
53929 PyThreadState* __tstate = wxPyBeginAllowThreads();
53930 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53931 wxPyEndAllowThreads(__tstate);
53932 if (PyErr_Occurred()) SWIG_fail;
53933 }
53934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53935 return resultobj;
53936 fail:
53937 return NULL;
53938 }
53939
53940
53941 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53942 PyObject *resultobj = 0;
53943 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53944 PyObject *arg2 = (PyObject *) 0 ;
53945 wxGBPosition *arg3 = 0 ;
53946 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53947 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53948 int arg5 = (int) 0 ;
53949 int arg6 = (int) 0 ;
53950 PyObject *arg7 = (PyObject *) NULL ;
53951 wxGBSizerItem *result = 0 ;
53952 void *argp1 = 0 ;
53953 int res1 = 0 ;
53954 wxGBPosition temp3 ;
53955 wxGBSpan temp4 ;
53956 int val5 ;
53957 int ecode5 = 0 ;
53958 int val6 ;
53959 int ecode6 = 0 ;
53960 PyObject * obj0 = 0 ;
53961 PyObject * obj1 = 0 ;
53962 PyObject * obj2 = 0 ;
53963 PyObject * obj3 = 0 ;
53964 PyObject * obj4 = 0 ;
53965 PyObject * obj5 = 0 ;
53966 PyObject * obj6 = 0 ;
53967 char * kwnames[] = {
53968 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53969 };
53970
53971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53973 if (!SWIG_IsOK(res1)) {
53974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53975 }
53976 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53977 arg2 = obj1;
53978 {
53979 arg3 = &temp3;
53980 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53981 }
53982 if (obj3) {
53983 {
53984 arg4 = &temp4;
53985 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53986 }
53987 }
53988 if (obj4) {
53989 ecode5 = SWIG_AsVal_int(obj4, &val5);
53990 if (!SWIG_IsOK(ecode5)) {
53991 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53992 }
53993 arg5 = static_cast< int >(val5);
53994 }
53995 if (obj5) {
53996 ecode6 = SWIG_AsVal_int(obj5, &val6);
53997 if (!SWIG_IsOK(ecode6)) {
53998 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53999 }
54000 arg6 = static_cast< int >(val6);
54001 }
54002 if (obj6) {
54003 arg7 = obj6;
54004 }
54005 {
54006 PyThreadState* __tstate = wxPyBeginAllowThreads();
54007 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54008 wxPyEndAllowThreads(__tstate);
54009 if (PyErr_Occurred()) SWIG_fail;
54010 }
54011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54012 return resultobj;
54013 fail:
54014 return NULL;
54015 }
54016
54017
54018 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54019 PyObject *resultobj = 0;
54020 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54021 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54022 wxGBSizerItem *result = 0 ;
54023 void *argp1 = 0 ;
54024 int res1 = 0 ;
54025 int res2 = 0 ;
54026 PyObject * obj0 = 0 ;
54027 PyObject * obj1 = 0 ;
54028 char * kwnames[] = {
54029 (char *) "self",(char *) "item", NULL
54030 };
54031
54032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54034 if (!SWIG_IsOK(res1)) {
54035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54036 }
54037 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54038 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54039 if (!SWIG_IsOK(res2)) {
54040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54041 }
54042 {
54043 PyThreadState* __tstate = wxPyBeginAllowThreads();
54044 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54045 wxPyEndAllowThreads(__tstate);
54046 if (PyErr_Occurred()) SWIG_fail;
54047 }
54048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54049 return resultobj;
54050 fail:
54051 return NULL;
54052 }
54053
54054
54055 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54056 PyObject *resultobj = 0;
54057 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54058 int arg2 ;
54059 int arg3 ;
54060 wxSize result;
54061 void *argp1 = 0 ;
54062 int res1 = 0 ;
54063 int val2 ;
54064 int ecode2 = 0 ;
54065 int val3 ;
54066 int ecode3 = 0 ;
54067 PyObject * obj0 = 0 ;
54068 PyObject * obj1 = 0 ;
54069 PyObject * obj2 = 0 ;
54070 char * kwnames[] = {
54071 (char *) "self",(char *) "row",(char *) "col", NULL
54072 };
54073
54074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54076 if (!SWIG_IsOK(res1)) {
54077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54078 }
54079 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54080 ecode2 = SWIG_AsVal_int(obj1, &val2);
54081 if (!SWIG_IsOK(ecode2)) {
54082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54083 }
54084 arg2 = static_cast< int >(val2);
54085 ecode3 = SWIG_AsVal_int(obj2, &val3);
54086 if (!SWIG_IsOK(ecode3)) {
54087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54088 }
54089 arg3 = static_cast< int >(val3);
54090 {
54091 PyThreadState* __tstate = wxPyBeginAllowThreads();
54092 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54093 wxPyEndAllowThreads(__tstate);
54094 if (PyErr_Occurred()) SWIG_fail;
54095 }
54096 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54097 return resultobj;
54098 fail:
54099 return NULL;
54100 }
54101
54102
54103 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54104 PyObject *resultobj = 0;
54105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54106 wxSize result;
54107 void *argp1 = 0 ;
54108 int res1 = 0 ;
54109 PyObject *swig_obj[1] ;
54110
54111 if (!args) SWIG_fail;
54112 swig_obj[0] = args;
54113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54114 if (!SWIG_IsOK(res1)) {
54115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54116 }
54117 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54118 {
54119 PyThreadState* __tstate = wxPyBeginAllowThreads();
54120 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54121 wxPyEndAllowThreads(__tstate);
54122 if (PyErr_Occurred()) SWIG_fail;
54123 }
54124 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54125 return resultobj;
54126 fail:
54127 return NULL;
54128 }
54129
54130
54131 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54132 PyObject *resultobj = 0;
54133 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54134 wxSize *arg2 = 0 ;
54135 void *argp1 = 0 ;
54136 int res1 = 0 ;
54137 wxSize temp2 ;
54138 PyObject * obj0 = 0 ;
54139 PyObject * obj1 = 0 ;
54140 char * kwnames[] = {
54141 (char *) "self",(char *) "sz", NULL
54142 };
54143
54144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54146 if (!SWIG_IsOK(res1)) {
54147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54148 }
54149 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54150 {
54151 arg2 = &temp2;
54152 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54153 }
54154 {
54155 PyThreadState* __tstate = wxPyBeginAllowThreads();
54156 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54157 wxPyEndAllowThreads(__tstate);
54158 if (PyErr_Occurred()) SWIG_fail;
54159 }
54160 resultobj = SWIG_Py_Void();
54161 return resultobj;
54162 fail:
54163 return NULL;
54164 }
54165
54166
54167 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54168 PyObject *resultobj = 0;
54169 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54170 wxWindow *arg2 = (wxWindow *) 0 ;
54171 wxGBPosition result;
54172 void *argp1 = 0 ;
54173 int res1 = 0 ;
54174 void *argp2 = 0 ;
54175 int res2 = 0 ;
54176
54177 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54179 if (!SWIG_IsOK(res1)) {
54180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54181 }
54182 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54183 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54184 if (!SWIG_IsOK(res2)) {
54185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54186 }
54187 arg2 = reinterpret_cast< wxWindow * >(argp2);
54188 {
54189 PyThreadState* __tstate = wxPyBeginAllowThreads();
54190 result = (arg1)->GetItemPosition(arg2);
54191 wxPyEndAllowThreads(__tstate);
54192 if (PyErr_Occurred()) SWIG_fail;
54193 }
54194 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54195 return resultobj;
54196 fail:
54197 return NULL;
54198 }
54199
54200
54201 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54202 PyObject *resultobj = 0;
54203 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54204 wxSizer *arg2 = (wxSizer *) 0 ;
54205 wxGBPosition result;
54206 void *argp1 = 0 ;
54207 int res1 = 0 ;
54208 void *argp2 = 0 ;
54209 int res2 = 0 ;
54210
54211 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54213 if (!SWIG_IsOK(res1)) {
54214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54215 }
54216 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54217 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54218 if (!SWIG_IsOK(res2)) {
54219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54220 }
54221 arg2 = reinterpret_cast< wxSizer * >(argp2);
54222 {
54223 PyThreadState* __tstate = wxPyBeginAllowThreads();
54224 result = (arg1)->GetItemPosition(arg2);
54225 wxPyEndAllowThreads(__tstate);
54226 if (PyErr_Occurred()) SWIG_fail;
54227 }
54228 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54229 return resultobj;
54230 fail:
54231 return NULL;
54232 }
54233
54234
54235 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54236 PyObject *resultobj = 0;
54237 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54238 size_t arg2 ;
54239 wxGBPosition result;
54240 void *argp1 = 0 ;
54241 int res1 = 0 ;
54242 size_t val2 ;
54243 int ecode2 = 0 ;
54244
54245 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54247 if (!SWIG_IsOK(res1)) {
54248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54249 }
54250 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54251 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54252 if (!SWIG_IsOK(ecode2)) {
54253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54254 }
54255 arg2 = static_cast< size_t >(val2);
54256 {
54257 PyThreadState* __tstate = wxPyBeginAllowThreads();
54258 result = (arg1)->GetItemPosition(arg2);
54259 wxPyEndAllowThreads(__tstate);
54260 if (PyErr_Occurred()) SWIG_fail;
54261 }
54262 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54263 return resultobj;
54264 fail:
54265 return NULL;
54266 }
54267
54268
54269 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54270 int argc;
54271 PyObject *argv[3];
54272
54273 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54274 --argc;
54275 if (argc == 2) {
54276 int _v = 0;
54277 {
54278 void *vptr = 0;
54279 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54280 _v = SWIG_CheckState(res);
54281 }
54282 if (!_v) goto check_1;
54283 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54284 }
54285 check_1:
54286
54287 if (argc == 2) {
54288 int _v = 0;
54289 {
54290 void *vptr = 0;
54291 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54292 _v = SWIG_CheckState(res);
54293 }
54294 if (!_v) goto check_2;
54295 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54296 }
54297 check_2:
54298
54299 if (argc == 2) {
54300 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54301 }
54302
54303 fail:
54304 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54305 return NULL;
54306 }
54307
54308
54309 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54310 PyObject *resultobj = 0;
54311 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54312 wxWindow *arg2 = (wxWindow *) 0 ;
54313 wxGBPosition *arg3 = 0 ;
54314 bool result;
54315 void *argp1 = 0 ;
54316 int res1 = 0 ;
54317 void *argp2 = 0 ;
54318 int res2 = 0 ;
54319 wxGBPosition temp3 ;
54320
54321 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54323 if (!SWIG_IsOK(res1)) {
54324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54325 }
54326 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54327 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54328 if (!SWIG_IsOK(res2)) {
54329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54330 }
54331 arg2 = reinterpret_cast< wxWindow * >(argp2);
54332 {
54333 arg3 = &temp3;
54334 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54335 }
54336 {
54337 PyThreadState* __tstate = wxPyBeginAllowThreads();
54338 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54339 wxPyEndAllowThreads(__tstate);
54340 if (PyErr_Occurred()) SWIG_fail;
54341 }
54342 {
54343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54344 }
54345 return resultobj;
54346 fail:
54347 return NULL;
54348 }
54349
54350
54351 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54352 PyObject *resultobj = 0;
54353 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54354 wxSizer *arg2 = (wxSizer *) 0 ;
54355 wxGBPosition *arg3 = 0 ;
54356 bool result;
54357 void *argp1 = 0 ;
54358 int res1 = 0 ;
54359 void *argp2 = 0 ;
54360 int res2 = 0 ;
54361 wxGBPosition temp3 ;
54362
54363 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54365 if (!SWIG_IsOK(res1)) {
54366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54367 }
54368 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54369 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54370 if (!SWIG_IsOK(res2)) {
54371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54372 }
54373 arg2 = reinterpret_cast< wxSizer * >(argp2);
54374 {
54375 arg3 = &temp3;
54376 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54377 }
54378 {
54379 PyThreadState* __tstate = wxPyBeginAllowThreads();
54380 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54381 wxPyEndAllowThreads(__tstate);
54382 if (PyErr_Occurred()) SWIG_fail;
54383 }
54384 {
54385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54386 }
54387 return resultobj;
54388 fail:
54389 return NULL;
54390 }
54391
54392
54393 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54394 PyObject *resultobj = 0;
54395 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54396 size_t arg2 ;
54397 wxGBPosition *arg3 = 0 ;
54398 bool result;
54399 void *argp1 = 0 ;
54400 int res1 = 0 ;
54401 size_t val2 ;
54402 int ecode2 = 0 ;
54403 wxGBPosition temp3 ;
54404
54405 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54407 if (!SWIG_IsOK(res1)) {
54408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54409 }
54410 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54411 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54412 if (!SWIG_IsOK(ecode2)) {
54413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54414 }
54415 arg2 = static_cast< size_t >(val2);
54416 {
54417 arg3 = &temp3;
54418 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54419 }
54420 {
54421 PyThreadState* __tstate = wxPyBeginAllowThreads();
54422 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54423 wxPyEndAllowThreads(__tstate);
54424 if (PyErr_Occurred()) SWIG_fail;
54425 }
54426 {
54427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54428 }
54429 return resultobj;
54430 fail:
54431 return NULL;
54432 }
54433
54434
54435 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54436 int argc;
54437 PyObject *argv[4];
54438
54439 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54440 --argc;
54441 if (argc == 3) {
54442 int _v = 0;
54443 {
54444 void *vptr = 0;
54445 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54446 _v = SWIG_CheckState(res);
54447 }
54448 if (!_v) goto check_1;
54449 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54450 }
54451 check_1:
54452
54453 if (argc == 3) {
54454 int _v = 0;
54455 {
54456 void *vptr = 0;
54457 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54458 _v = SWIG_CheckState(res);
54459 }
54460 if (!_v) goto check_2;
54461 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54462 }
54463 check_2:
54464
54465 if (argc == 3) {
54466 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54467 }
54468
54469 fail:
54470 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54471 return NULL;
54472 }
54473
54474
54475 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54476 PyObject *resultobj = 0;
54477 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54478 wxWindow *arg2 = (wxWindow *) 0 ;
54479 wxGBSpan result;
54480 void *argp1 = 0 ;
54481 int res1 = 0 ;
54482 void *argp2 = 0 ;
54483 int res2 = 0 ;
54484
54485 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54487 if (!SWIG_IsOK(res1)) {
54488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54489 }
54490 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54491 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54492 if (!SWIG_IsOK(res2)) {
54493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54494 }
54495 arg2 = reinterpret_cast< wxWindow * >(argp2);
54496 {
54497 PyThreadState* __tstate = wxPyBeginAllowThreads();
54498 result = (arg1)->GetItemSpan(arg2);
54499 wxPyEndAllowThreads(__tstate);
54500 if (PyErr_Occurred()) SWIG_fail;
54501 }
54502 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54503 return resultobj;
54504 fail:
54505 return NULL;
54506 }
54507
54508
54509 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54510 PyObject *resultobj = 0;
54511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54512 wxSizer *arg2 = (wxSizer *) 0 ;
54513 wxGBSpan result;
54514 void *argp1 = 0 ;
54515 int res1 = 0 ;
54516 void *argp2 = 0 ;
54517 int res2 = 0 ;
54518
54519 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54521 if (!SWIG_IsOK(res1)) {
54522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54523 }
54524 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54525 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54526 if (!SWIG_IsOK(res2)) {
54527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54528 }
54529 arg2 = reinterpret_cast< wxSizer * >(argp2);
54530 {
54531 PyThreadState* __tstate = wxPyBeginAllowThreads();
54532 result = (arg1)->GetItemSpan(arg2);
54533 wxPyEndAllowThreads(__tstate);
54534 if (PyErr_Occurred()) SWIG_fail;
54535 }
54536 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54537 return resultobj;
54538 fail:
54539 return NULL;
54540 }
54541
54542
54543 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54544 PyObject *resultobj = 0;
54545 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54546 size_t arg2 ;
54547 wxGBSpan result;
54548 void *argp1 = 0 ;
54549 int res1 = 0 ;
54550 size_t val2 ;
54551 int ecode2 = 0 ;
54552
54553 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54555 if (!SWIG_IsOK(res1)) {
54556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54557 }
54558 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54559 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54560 if (!SWIG_IsOK(ecode2)) {
54561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54562 }
54563 arg2 = static_cast< size_t >(val2);
54564 {
54565 PyThreadState* __tstate = wxPyBeginAllowThreads();
54566 result = (arg1)->GetItemSpan(arg2);
54567 wxPyEndAllowThreads(__tstate);
54568 if (PyErr_Occurred()) SWIG_fail;
54569 }
54570 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54571 return resultobj;
54572 fail:
54573 return NULL;
54574 }
54575
54576
54577 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54578 int argc;
54579 PyObject *argv[3];
54580
54581 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54582 --argc;
54583 if (argc == 2) {
54584 int _v = 0;
54585 {
54586 void *vptr = 0;
54587 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54588 _v = SWIG_CheckState(res);
54589 }
54590 if (!_v) goto check_1;
54591 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54592 }
54593 check_1:
54594
54595 if (argc == 2) {
54596 int _v = 0;
54597 {
54598 void *vptr = 0;
54599 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54600 _v = SWIG_CheckState(res);
54601 }
54602 if (!_v) goto check_2;
54603 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54604 }
54605 check_2:
54606
54607 if (argc == 2) {
54608 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54609 }
54610
54611 fail:
54612 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54613 return NULL;
54614 }
54615
54616
54617 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54618 PyObject *resultobj = 0;
54619 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54620 wxWindow *arg2 = (wxWindow *) 0 ;
54621 wxGBSpan *arg3 = 0 ;
54622 bool result;
54623 void *argp1 = 0 ;
54624 int res1 = 0 ;
54625 void *argp2 = 0 ;
54626 int res2 = 0 ;
54627 wxGBSpan temp3 ;
54628
54629 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54631 if (!SWIG_IsOK(res1)) {
54632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54633 }
54634 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54635 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54636 if (!SWIG_IsOK(res2)) {
54637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54638 }
54639 arg2 = reinterpret_cast< wxWindow * >(argp2);
54640 {
54641 arg3 = &temp3;
54642 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54643 }
54644 {
54645 PyThreadState* __tstate = wxPyBeginAllowThreads();
54646 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54647 wxPyEndAllowThreads(__tstate);
54648 if (PyErr_Occurred()) SWIG_fail;
54649 }
54650 {
54651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54652 }
54653 return resultobj;
54654 fail:
54655 return NULL;
54656 }
54657
54658
54659 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54660 PyObject *resultobj = 0;
54661 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54662 wxSizer *arg2 = (wxSizer *) 0 ;
54663 wxGBSpan *arg3 = 0 ;
54664 bool result;
54665 void *argp1 = 0 ;
54666 int res1 = 0 ;
54667 void *argp2 = 0 ;
54668 int res2 = 0 ;
54669 wxGBSpan temp3 ;
54670
54671 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54673 if (!SWIG_IsOK(res1)) {
54674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54675 }
54676 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54677 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54678 if (!SWIG_IsOK(res2)) {
54679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54680 }
54681 arg2 = reinterpret_cast< wxSizer * >(argp2);
54682 {
54683 arg3 = &temp3;
54684 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54685 }
54686 {
54687 PyThreadState* __tstate = wxPyBeginAllowThreads();
54688 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54689 wxPyEndAllowThreads(__tstate);
54690 if (PyErr_Occurred()) SWIG_fail;
54691 }
54692 {
54693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54694 }
54695 return resultobj;
54696 fail:
54697 return NULL;
54698 }
54699
54700
54701 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54702 PyObject *resultobj = 0;
54703 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54704 size_t arg2 ;
54705 wxGBSpan *arg3 = 0 ;
54706 bool result;
54707 void *argp1 = 0 ;
54708 int res1 = 0 ;
54709 size_t val2 ;
54710 int ecode2 = 0 ;
54711 wxGBSpan temp3 ;
54712
54713 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54715 if (!SWIG_IsOK(res1)) {
54716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54717 }
54718 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54719 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54720 if (!SWIG_IsOK(ecode2)) {
54721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54722 }
54723 arg2 = static_cast< size_t >(val2);
54724 {
54725 arg3 = &temp3;
54726 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54727 }
54728 {
54729 PyThreadState* __tstate = wxPyBeginAllowThreads();
54730 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54731 wxPyEndAllowThreads(__tstate);
54732 if (PyErr_Occurred()) SWIG_fail;
54733 }
54734 {
54735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54736 }
54737 return resultobj;
54738 fail:
54739 return NULL;
54740 }
54741
54742
54743 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54744 int argc;
54745 PyObject *argv[4];
54746
54747 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54748 --argc;
54749 if (argc == 3) {
54750 int _v = 0;
54751 {
54752 void *vptr = 0;
54753 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54754 _v = SWIG_CheckState(res);
54755 }
54756 if (!_v) goto check_1;
54757 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54758 }
54759 check_1:
54760
54761 if (argc == 3) {
54762 int _v = 0;
54763 {
54764 void *vptr = 0;
54765 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54766 _v = SWIG_CheckState(res);
54767 }
54768 if (!_v) goto check_2;
54769 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54770 }
54771 check_2:
54772
54773 if (argc == 3) {
54774 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54775 }
54776
54777 fail:
54778 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54779 return NULL;
54780 }
54781
54782
54783 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54784 PyObject *resultobj = 0;
54785 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54786 wxWindow *arg2 = (wxWindow *) 0 ;
54787 wxGBSizerItem *result = 0 ;
54788 void *argp1 = 0 ;
54789 int res1 = 0 ;
54790 void *argp2 = 0 ;
54791 int res2 = 0 ;
54792
54793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54795 if (!SWIG_IsOK(res1)) {
54796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54797 }
54798 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54799 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54800 if (!SWIG_IsOK(res2)) {
54801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54802 }
54803 arg2 = reinterpret_cast< wxWindow * >(argp2);
54804 {
54805 PyThreadState* __tstate = wxPyBeginAllowThreads();
54806 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54807 wxPyEndAllowThreads(__tstate);
54808 if (PyErr_Occurred()) SWIG_fail;
54809 }
54810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54811 return resultobj;
54812 fail:
54813 return NULL;
54814 }
54815
54816
54817 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54818 PyObject *resultobj = 0;
54819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54820 wxSizer *arg2 = (wxSizer *) 0 ;
54821 wxGBSizerItem *result = 0 ;
54822 void *argp1 = 0 ;
54823 int res1 = 0 ;
54824 void *argp2 = 0 ;
54825 int res2 = 0 ;
54826
54827 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54829 if (!SWIG_IsOK(res1)) {
54830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54831 }
54832 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54833 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54834 if (!SWIG_IsOK(res2)) {
54835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54836 }
54837 arg2 = reinterpret_cast< wxSizer * >(argp2);
54838 {
54839 PyThreadState* __tstate = wxPyBeginAllowThreads();
54840 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54841 wxPyEndAllowThreads(__tstate);
54842 if (PyErr_Occurred()) SWIG_fail;
54843 }
54844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54845 return resultobj;
54846 fail:
54847 return NULL;
54848 }
54849
54850
54851 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54852 int argc;
54853 PyObject *argv[3];
54854
54855 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54856 --argc;
54857 if (argc == 2) {
54858 int _v = 0;
54859 {
54860 void *vptr = 0;
54861 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54862 _v = SWIG_CheckState(res);
54863 }
54864 if (!_v) goto check_1;
54865 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54866 }
54867 check_1:
54868
54869 if (argc == 2) {
54870 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54871 }
54872
54873 fail:
54874 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54875 return NULL;
54876 }
54877
54878
54879 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54880 PyObject *resultobj = 0;
54881 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54882 wxGBPosition *arg2 = 0 ;
54883 wxGBSizerItem *result = 0 ;
54884 void *argp1 = 0 ;
54885 int res1 = 0 ;
54886 wxGBPosition temp2 ;
54887 PyObject * obj0 = 0 ;
54888 PyObject * obj1 = 0 ;
54889 char * kwnames[] = {
54890 (char *) "self",(char *) "pos", NULL
54891 };
54892
54893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54895 if (!SWIG_IsOK(res1)) {
54896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54897 }
54898 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54899 {
54900 arg2 = &temp2;
54901 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54902 }
54903 {
54904 PyThreadState* __tstate = wxPyBeginAllowThreads();
54905 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54906 wxPyEndAllowThreads(__tstate);
54907 if (PyErr_Occurred()) SWIG_fail;
54908 }
54909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54910 return resultobj;
54911 fail:
54912 return NULL;
54913 }
54914
54915
54916 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54917 PyObject *resultobj = 0;
54918 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54919 wxPoint *arg2 = 0 ;
54920 wxGBSizerItem *result = 0 ;
54921 void *argp1 = 0 ;
54922 int res1 = 0 ;
54923 wxPoint temp2 ;
54924 PyObject * obj0 = 0 ;
54925 PyObject * obj1 = 0 ;
54926 char * kwnames[] = {
54927 (char *) "self",(char *) "pt", NULL
54928 };
54929
54930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54932 if (!SWIG_IsOK(res1)) {
54933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54934 }
54935 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54936 {
54937 arg2 = &temp2;
54938 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54939 }
54940 {
54941 PyThreadState* __tstate = wxPyBeginAllowThreads();
54942 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54943 wxPyEndAllowThreads(__tstate);
54944 if (PyErr_Occurred()) SWIG_fail;
54945 }
54946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54947 return resultobj;
54948 fail:
54949 return NULL;
54950 }
54951
54952
54953 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54954 PyObject *resultobj = 0;
54955 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54956 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54957 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54958 bool result;
54959 void *argp1 = 0 ;
54960 int res1 = 0 ;
54961 void *argp2 = 0 ;
54962 int res2 = 0 ;
54963 void *argp3 = 0 ;
54964 int res3 = 0 ;
54965 PyObject * obj0 = 0 ;
54966 PyObject * obj1 = 0 ;
54967 PyObject * obj2 = 0 ;
54968 char * kwnames[] = {
54969 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54970 };
54971
54972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54974 if (!SWIG_IsOK(res1)) {
54975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54976 }
54977 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54979 if (!SWIG_IsOK(res2)) {
54980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54981 }
54982 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54983 if (obj2) {
54984 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54985 if (!SWIG_IsOK(res3)) {
54986 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54987 }
54988 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54989 }
54990 {
54991 PyThreadState* __tstate = wxPyBeginAllowThreads();
54992 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54993 wxPyEndAllowThreads(__tstate);
54994 if (PyErr_Occurred()) SWIG_fail;
54995 }
54996 {
54997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54998 }
54999 return resultobj;
55000 fail:
55001 return NULL;
55002 }
55003
55004
55005 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55006 PyObject *resultobj = 0;
55007 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55008 wxGBPosition *arg2 = 0 ;
55009 wxGBSpan *arg3 = 0 ;
55010 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55011 bool result;
55012 void *argp1 = 0 ;
55013 int res1 = 0 ;
55014 wxGBPosition temp2 ;
55015 wxGBSpan temp3 ;
55016 void *argp4 = 0 ;
55017 int res4 = 0 ;
55018 PyObject * obj0 = 0 ;
55019 PyObject * obj1 = 0 ;
55020 PyObject * obj2 = 0 ;
55021 PyObject * obj3 = 0 ;
55022 char * kwnames[] = {
55023 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55024 };
55025
55026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55028 if (!SWIG_IsOK(res1)) {
55029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55030 }
55031 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55032 {
55033 arg2 = &temp2;
55034 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55035 }
55036 {
55037 arg3 = &temp3;
55038 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55039 }
55040 if (obj3) {
55041 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55042 if (!SWIG_IsOK(res4)) {
55043 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55044 }
55045 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55046 }
55047 {
55048 PyThreadState* __tstate = wxPyBeginAllowThreads();
55049 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55050 wxPyEndAllowThreads(__tstate);
55051 if (PyErr_Occurred()) SWIG_fail;
55052 }
55053 {
55054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55055 }
55056 return resultobj;
55057 fail:
55058 return NULL;
55059 }
55060
55061
55062 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55063 PyObject *obj;
55064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55065 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55066 return SWIG_Py_Void();
55067 }
55068
55069 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55070 return SWIG_Python_InitShadowInstance(args);
55071 }
55072
55073 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55074 PyObject *resultobj = 0;
55075 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55076 wxRelationship arg2 ;
55077 wxWindow *arg3 = (wxWindow *) 0 ;
55078 wxEdge arg4 ;
55079 int arg5 = (int) 0 ;
55080 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55081 void *argp1 = 0 ;
55082 int res1 = 0 ;
55083 int val2 ;
55084 int ecode2 = 0 ;
55085 void *argp3 = 0 ;
55086 int res3 = 0 ;
55087 int val4 ;
55088 int ecode4 = 0 ;
55089 int val5 ;
55090 int ecode5 = 0 ;
55091 int val6 ;
55092 int ecode6 = 0 ;
55093 PyObject * obj0 = 0 ;
55094 PyObject * obj1 = 0 ;
55095 PyObject * obj2 = 0 ;
55096 PyObject * obj3 = 0 ;
55097 PyObject * obj4 = 0 ;
55098 PyObject * obj5 = 0 ;
55099 char * kwnames[] = {
55100 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55101 };
55102
55103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55105 if (!SWIG_IsOK(res1)) {
55106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55107 }
55108 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55109 ecode2 = SWIG_AsVal_int(obj1, &val2);
55110 if (!SWIG_IsOK(ecode2)) {
55111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55112 }
55113 arg2 = static_cast< wxRelationship >(val2);
55114 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55115 if (!SWIG_IsOK(res3)) {
55116 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55117 }
55118 arg3 = reinterpret_cast< wxWindow * >(argp3);
55119 ecode4 = SWIG_AsVal_int(obj3, &val4);
55120 if (!SWIG_IsOK(ecode4)) {
55121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55122 }
55123 arg4 = static_cast< wxEdge >(val4);
55124 if (obj4) {
55125 ecode5 = SWIG_AsVal_int(obj4, &val5);
55126 if (!SWIG_IsOK(ecode5)) {
55127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55128 }
55129 arg5 = static_cast< int >(val5);
55130 }
55131 if (obj5) {
55132 ecode6 = SWIG_AsVal_int(obj5, &val6);
55133 if (!SWIG_IsOK(ecode6)) {
55134 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55135 }
55136 arg6 = static_cast< int >(val6);
55137 }
55138 {
55139 PyThreadState* __tstate = wxPyBeginAllowThreads();
55140 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55141 wxPyEndAllowThreads(__tstate);
55142 if (PyErr_Occurred()) SWIG_fail;
55143 }
55144 resultobj = SWIG_Py_Void();
55145 return resultobj;
55146 fail:
55147 return NULL;
55148 }
55149
55150
55151 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55152 PyObject *resultobj = 0;
55153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55154 wxWindow *arg2 = (wxWindow *) 0 ;
55155 int arg3 = (int) 0 ;
55156 void *argp1 = 0 ;
55157 int res1 = 0 ;
55158 void *argp2 = 0 ;
55159 int res2 = 0 ;
55160 int val3 ;
55161 int ecode3 = 0 ;
55162 PyObject * obj0 = 0 ;
55163 PyObject * obj1 = 0 ;
55164 PyObject * obj2 = 0 ;
55165 char * kwnames[] = {
55166 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55167 };
55168
55169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55171 if (!SWIG_IsOK(res1)) {
55172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55173 }
55174 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55176 if (!SWIG_IsOK(res2)) {
55177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55178 }
55179 arg2 = reinterpret_cast< wxWindow * >(argp2);
55180 if (obj2) {
55181 ecode3 = SWIG_AsVal_int(obj2, &val3);
55182 if (!SWIG_IsOK(ecode3)) {
55183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55184 }
55185 arg3 = static_cast< int >(val3);
55186 }
55187 {
55188 PyThreadState* __tstate = wxPyBeginAllowThreads();
55189 (arg1)->LeftOf(arg2,arg3);
55190 wxPyEndAllowThreads(__tstate);
55191 if (PyErr_Occurred()) SWIG_fail;
55192 }
55193 resultobj = SWIG_Py_Void();
55194 return resultobj;
55195 fail:
55196 return NULL;
55197 }
55198
55199
55200 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55201 PyObject *resultobj = 0;
55202 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55203 wxWindow *arg2 = (wxWindow *) 0 ;
55204 int arg3 = (int) 0 ;
55205 void *argp1 = 0 ;
55206 int res1 = 0 ;
55207 void *argp2 = 0 ;
55208 int res2 = 0 ;
55209 int val3 ;
55210 int ecode3 = 0 ;
55211 PyObject * obj0 = 0 ;
55212 PyObject * obj1 = 0 ;
55213 PyObject * obj2 = 0 ;
55214 char * kwnames[] = {
55215 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55216 };
55217
55218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55220 if (!SWIG_IsOK(res1)) {
55221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55222 }
55223 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55225 if (!SWIG_IsOK(res2)) {
55226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55227 }
55228 arg2 = reinterpret_cast< wxWindow * >(argp2);
55229 if (obj2) {
55230 ecode3 = SWIG_AsVal_int(obj2, &val3);
55231 if (!SWIG_IsOK(ecode3)) {
55232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55233 }
55234 arg3 = static_cast< int >(val3);
55235 }
55236 {
55237 PyThreadState* __tstate = wxPyBeginAllowThreads();
55238 (arg1)->RightOf(arg2,arg3);
55239 wxPyEndAllowThreads(__tstate);
55240 if (PyErr_Occurred()) SWIG_fail;
55241 }
55242 resultobj = SWIG_Py_Void();
55243 return resultobj;
55244 fail:
55245 return NULL;
55246 }
55247
55248
55249 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55250 PyObject *resultobj = 0;
55251 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55252 wxWindow *arg2 = (wxWindow *) 0 ;
55253 int arg3 = (int) 0 ;
55254 void *argp1 = 0 ;
55255 int res1 = 0 ;
55256 void *argp2 = 0 ;
55257 int res2 = 0 ;
55258 int val3 ;
55259 int ecode3 = 0 ;
55260 PyObject * obj0 = 0 ;
55261 PyObject * obj1 = 0 ;
55262 PyObject * obj2 = 0 ;
55263 char * kwnames[] = {
55264 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55265 };
55266
55267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55269 if (!SWIG_IsOK(res1)) {
55270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55271 }
55272 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55274 if (!SWIG_IsOK(res2)) {
55275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55276 }
55277 arg2 = reinterpret_cast< wxWindow * >(argp2);
55278 if (obj2) {
55279 ecode3 = SWIG_AsVal_int(obj2, &val3);
55280 if (!SWIG_IsOK(ecode3)) {
55281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55282 }
55283 arg3 = static_cast< int >(val3);
55284 }
55285 {
55286 PyThreadState* __tstate = wxPyBeginAllowThreads();
55287 (arg1)->Above(arg2,arg3);
55288 wxPyEndAllowThreads(__tstate);
55289 if (PyErr_Occurred()) SWIG_fail;
55290 }
55291 resultobj = SWIG_Py_Void();
55292 return resultobj;
55293 fail:
55294 return NULL;
55295 }
55296
55297
55298 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55299 PyObject *resultobj = 0;
55300 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55301 wxWindow *arg2 = (wxWindow *) 0 ;
55302 int arg3 = (int) 0 ;
55303 void *argp1 = 0 ;
55304 int res1 = 0 ;
55305 void *argp2 = 0 ;
55306 int res2 = 0 ;
55307 int val3 ;
55308 int ecode3 = 0 ;
55309 PyObject * obj0 = 0 ;
55310 PyObject * obj1 = 0 ;
55311 PyObject * obj2 = 0 ;
55312 char * kwnames[] = {
55313 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55314 };
55315
55316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55318 if (!SWIG_IsOK(res1)) {
55319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55320 }
55321 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55323 if (!SWIG_IsOK(res2)) {
55324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55325 }
55326 arg2 = reinterpret_cast< wxWindow * >(argp2);
55327 if (obj2) {
55328 ecode3 = SWIG_AsVal_int(obj2, &val3);
55329 if (!SWIG_IsOK(ecode3)) {
55330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55331 }
55332 arg3 = static_cast< int >(val3);
55333 }
55334 {
55335 PyThreadState* __tstate = wxPyBeginAllowThreads();
55336 (arg1)->Below(arg2,arg3);
55337 wxPyEndAllowThreads(__tstate);
55338 if (PyErr_Occurred()) SWIG_fail;
55339 }
55340 resultobj = SWIG_Py_Void();
55341 return resultobj;
55342 fail:
55343 return NULL;
55344 }
55345
55346
55347 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55348 PyObject *resultobj = 0;
55349 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55350 wxWindow *arg2 = (wxWindow *) 0 ;
55351 wxEdge arg3 ;
55352 int arg4 = (int) 0 ;
55353 void *argp1 = 0 ;
55354 int res1 = 0 ;
55355 void *argp2 = 0 ;
55356 int res2 = 0 ;
55357 int val3 ;
55358 int ecode3 = 0 ;
55359 int val4 ;
55360 int ecode4 = 0 ;
55361 PyObject * obj0 = 0 ;
55362 PyObject * obj1 = 0 ;
55363 PyObject * obj2 = 0 ;
55364 PyObject * obj3 = 0 ;
55365 char * kwnames[] = {
55366 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55367 };
55368
55369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55371 if (!SWIG_IsOK(res1)) {
55372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55373 }
55374 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55376 if (!SWIG_IsOK(res2)) {
55377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55378 }
55379 arg2 = reinterpret_cast< wxWindow * >(argp2);
55380 ecode3 = SWIG_AsVal_int(obj2, &val3);
55381 if (!SWIG_IsOK(ecode3)) {
55382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55383 }
55384 arg3 = static_cast< wxEdge >(val3);
55385 if (obj3) {
55386 ecode4 = SWIG_AsVal_int(obj3, &val4);
55387 if (!SWIG_IsOK(ecode4)) {
55388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55389 }
55390 arg4 = static_cast< int >(val4);
55391 }
55392 {
55393 PyThreadState* __tstate = wxPyBeginAllowThreads();
55394 (arg1)->SameAs(arg2,arg3,arg4);
55395 wxPyEndAllowThreads(__tstate);
55396 if (PyErr_Occurred()) SWIG_fail;
55397 }
55398 resultobj = SWIG_Py_Void();
55399 return resultobj;
55400 fail:
55401 return NULL;
55402 }
55403
55404
55405 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55406 PyObject *resultobj = 0;
55407 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55408 wxWindow *arg2 = (wxWindow *) 0 ;
55409 wxEdge arg3 ;
55410 int arg4 ;
55411 void *argp1 = 0 ;
55412 int res1 = 0 ;
55413 void *argp2 = 0 ;
55414 int res2 = 0 ;
55415 int val3 ;
55416 int ecode3 = 0 ;
55417 int val4 ;
55418 int ecode4 = 0 ;
55419 PyObject * obj0 = 0 ;
55420 PyObject * obj1 = 0 ;
55421 PyObject * obj2 = 0 ;
55422 PyObject * obj3 = 0 ;
55423 char * kwnames[] = {
55424 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55425 };
55426
55427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55429 if (!SWIG_IsOK(res1)) {
55430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55431 }
55432 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55433 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55434 if (!SWIG_IsOK(res2)) {
55435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55436 }
55437 arg2 = reinterpret_cast< wxWindow * >(argp2);
55438 ecode3 = SWIG_AsVal_int(obj2, &val3);
55439 if (!SWIG_IsOK(ecode3)) {
55440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55441 }
55442 arg3 = static_cast< wxEdge >(val3);
55443 ecode4 = SWIG_AsVal_int(obj3, &val4);
55444 if (!SWIG_IsOK(ecode4)) {
55445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55446 }
55447 arg4 = static_cast< int >(val4);
55448 {
55449 PyThreadState* __tstate = wxPyBeginAllowThreads();
55450 (arg1)->PercentOf(arg2,arg3,arg4);
55451 wxPyEndAllowThreads(__tstate);
55452 if (PyErr_Occurred()) SWIG_fail;
55453 }
55454 resultobj = SWIG_Py_Void();
55455 return resultobj;
55456 fail:
55457 return NULL;
55458 }
55459
55460
55461 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55462 PyObject *resultobj = 0;
55463 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55464 int arg2 ;
55465 void *argp1 = 0 ;
55466 int res1 = 0 ;
55467 int val2 ;
55468 int ecode2 = 0 ;
55469 PyObject * obj0 = 0 ;
55470 PyObject * obj1 = 0 ;
55471 char * kwnames[] = {
55472 (char *) "self",(char *) "val", NULL
55473 };
55474
55475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55477 if (!SWIG_IsOK(res1)) {
55478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55479 }
55480 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55481 ecode2 = SWIG_AsVal_int(obj1, &val2);
55482 if (!SWIG_IsOK(ecode2)) {
55483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55484 }
55485 arg2 = static_cast< int >(val2);
55486 {
55487 PyThreadState* __tstate = wxPyBeginAllowThreads();
55488 (arg1)->Absolute(arg2);
55489 wxPyEndAllowThreads(__tstate);
55490 if (PyErr_Occurred()) SWIG_fail;
55491 }
55492 resultobj = SWIG_Py_Void();
55493 return resultobj;
55494 fail:
55495 return NULL;
55496 }
55497
55498
55499 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55500 PyObject *resultobj = 0;
55501 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55502 void *argp1 = 0 ;
55503 int res1 = 0 ;
55504 PyObject *swig_obj[1] ;
55505
55506 if (!args) SWIG_fail;
55507 swig_obj[0] = args;
55508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55509 if (!SWIG_IsOK(res1)) {
55510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55511 }
55512 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55513 {
55514 PyThreadState* __tstate = wxPyBeginAllowThreads();
55515 (arg1)->Unconstrained();
55516 wxPyEndAllowThreads(__tstate);
55517 if (PyErr_Occurred()) SWIG_fail;
55518 }
55519 resultobj = SWIG_Py_Void();
55520 return resultobj;
55521 fail:
55522 return NULL;
55523 }
55524
55525
55526 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55527 PyObject *resultobj = 0;
55528 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55529 void *argp1 = 0 ;
55530 int res1 = 0 ;
55531 PyObject *swig_obj[1] ;
55532
55533 if (!args) SWIG_fail;
55534 swig_obj[0] = args;
55535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55536 if (!SWIG_IsOK(res1)) {
55537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55538 }
55539 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55540 {
55541 PyThreadState* __tstate = wxPyBeginAllowThreads();
55542 (arg1)->AsIs();
55543 wxPyEndAllowThreads(__tstate);
55544 if (PyErr_Occurred()) SWIG_fail;
55545 }
55546 resultobj = SWIG_Py_Void();
55547 return resultobj;
55548 fail:
55549 return NULL;
55550 }
55551
55552
55553 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55554 PyObject *resultobj = 0;
55555 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55556 wxWindow *result = 0 ;
55557 void *argp1 = 0 ;
55558 int res1 = 0 ;
55559 PyObject *swig_obj[1] ;
55560
55561 if (!args) SWIG_fail;
55562 swig_obj[0] = args;
55563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55564 if (!SWIG_IsOK(res1)) {
55565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55566 }
55567 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55568 {
55569 PyThreadState* __tstate = wxPyBeginAllowThreads();
55570 result = (wxWindow *)(arg1)->GetOtherWindow();
55571 wxPyEndAllowThreads(__tstate);
55572 if (PyErr_Occurred()) SWIG_fail;
55573 }
55574 {
55575 resultobj = wxPyMake_wxObject(result, 0);
55576 }
55577 return resultobj;
55578 fail:
55579 return NULL;
55580 }
55581
55582
55583 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55584 PyObject *resultobj = 0;
55585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55586 wxEdge result;
55587 void *argp1 = 0 ;
55588 int res1 = 0 ;
55589 PyObject *swig_obj[1] ;
55590
55591 if (!args) SWIG_fail;
55592 swig_obj[0] = args;
55593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55594 if (!SWIG_IsOK(res1)) {
55595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55596 }
55597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55598 {
55599 PyThreadState* __tstate = wxPyBeginAllowThreads();
55600 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55601 wxPyEndAllowThreads(__tstate);
55602 if (PyErr_Occurred()) SWIG_fail;
55603 }
55604 resultobj = SWIG_From_int(static_cast< int >(result));
55605 return resultobj;
55606 fail:
55607 return NULL;
55608 }
55609
55610
55611 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55612 PyObject *resultobj = 0;
55613 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55614 wxEdge arg2 ;
55615 void *argp1 = 0 ;
55616 int res1 = 0 ;
55617 int val2 ;
55618 int ecode2 = 0 ;
55619 PyObject * obj0 = 0 ;
55620 PyObject * obj1 = 0 ;
55621 char * kwnames[] = {
55622 (char *) "self",(char *) "which", NULL
55623 };
55624
55625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55627 if (!SWIG_IsOK(res1)) {
55628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55629 }
55630 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55631 ecode2 = SWIG_AsVal_int(obj1, &val2);
55632 if (!SWIG_IsOK(ecode2)) {
55633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55634 }
55635 arg2 = static_cast< wxEdge >(val2);
55636 {
55637 PyThreadState* __tstate = wxPyBeginAllowThreads();
55638 (arg1)->SetEdge(arg2);
55639 wxPyEndAllowThreads(__tstate);
55640 if (PyErr_Occurred()) SWIG_fail;
55641 }
55642 resultobj = SWIG_Py_Void();
55643 return resultobj;
55644 fail:
55645 return NULL;
55646 }
55647
55648
55649 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55650 PyObject *resultobj = 0;
55651 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55652 int arg2 ;
55653 void *argp1 = 0 ;
55654 int res1 = 0 ;
55655 int val2 ;
55656 int ecode2 = 0 ;
55657 PyObject * obj0 = 0 ;
55658 PyObject * obj1 = 0 ;
55659 char * kwnames[] = {
55660 (char *) "self",(char *) "v", NULL
55661 };
55662
55663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55665 if (!SWIG_IsOK(res1)) {
55666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55667 }
55668 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55669 ecode2 = SWIG_AsVal_int(obj1, &val2);
55670 if (!SWIG_IsOK(ecode2)) {
55671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55672 }
55673 arg2 = static_cast< int >(val2);
55674 {
55675 PyThreadState* __tstate = wxPyBeginAllowThreads();
55676 (arg1)->SetValue(arg2);
55677 wxPyEndAllowThreads(__tstate);
55678 if (PyErr_Occurred()) SWIG_fail;
55679 }
55680 resultobj = SWIG_Py_Void();
55681 return resultobj;
55682 fail:
55683 return NULL;
55684 }
55685
55686
55687 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55688 PyObject *resultobj = 0;
55689 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55690 int result;
55691 void *argp1 = 0 ;
55692 int res1 = 0 ;
55693 PyObject *swig_obj[1] ;
55694
55695 if (!args) SWIG_fail;
55696 swig_obj[0] = args;
55697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55698 if (!SWIG_IsOK(res1)) {
55699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55700 }
55701 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55702 {
55703 PyThreadState* __tstate = wxPyBeginAllowThreads();
55704 result = (int)(arg1)->GetMargin();
55705 wxPyEndAllowThreads(__tstate);
55706 if (PyErr_Occurred()) SWIG_fail;
55707 }
55708 resultobj = SWIG_From_int(static_cast< int >(result));
55709 return resultobj;
55710 fail:
55711 return NULL;
55712 }
55713
55714
55715 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55716 PyObject *resultobj = 0;
55717 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55718 int arg2 ;
55719 void *argp1 = 0 ;
55720 int res1 = 0 ;
55721 int val2 ;
55722 int ecode2 = 0 ;
55723 PyObject * obj0 = 0 ;
55724 PyObject * obj1 = 0 ;
55725 char * kwnames[] = {
55726 (char *) "self",(char *) "m", NULL
55727 };
55728
55729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55731 if (!SWIG_IsOK(res1)) {
55732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55733 }
55734 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55735 ecode2 = SWIG_AsVal_int(obj1, &val2);
55736 if (!SWIG_IsOK(ecode2)) {
55737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55738 }
55739 arg2 = static_cast< int >(val2);
55740 {
55741 PyThreadState* __tstate = wxPyBeginAllowThreads();
55742 (arg1)->SetMargin(arg2);
55743 wxPyEndAllowThreads(__tstate);
55744 if (PyErr_Occurred()) SWIG_fail;
55745 }
55746 resultobj = SWIG_Py_Void();
55747 return resultobj;
55748 fail:
55749 return NULL;
55750 }
55751
55752
55753 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55754 PyObject *resultobj = 0;
55755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55756 int result;
55757 void *argp1 = 0 ;
55758 int res1 = 0 ;
55759 PyObject *swig_obj[1] ;
55760
55761 if (!args) SWIG_fail;
55762 swig_obj[0] = args;
55763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55764 if (!SWIG_IsOK(res1)) {
55765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55766 }
55767 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55768 {
55769 PyThreadState* __tstate = wxPyBeginAllowThreads();
55770 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55771 wxPyEndAllowThreads(__tstate);
55772 if (PyErr_Occurred()) SWIG_fail;
55773 }
55774 resultobj = SWIG_From_int(static_cast< int >(result));
55775 return resultobj;
55776 fail:
55777 return NULL;
55778 }
55779
55780
55781 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55782 PyObject *resultobj = 0;
55783 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55784 int result;
55785 void *argp1 = 0 ;
55786 int res1 = 0 ;
55787 PyObject *swig_obj[1] ;
55788
55789 if (!args) SWIG_fail;
55790 swig_obj[0] = args;
55791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55792 if (!SWIG_IsOK(res1)) {
55793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55794 }
55795 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55796 {
55797 PyThreadState* __tstate = wxPyBeginAllowThreads();
55798 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55799 wxPyEndAllowThreads(__tstate);
55800 if (PyErr_Occurred()) SWIG_fail;
55801 }
55802 resultobj = SWIG_From_int(static_cast< int >(result));
55803 return resultobj;
55804 fail:
55805 return NULL;
55806 }
55807
55808
55809 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55810 PyObject *resultobj = 0;
55811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55812 int result;
55813 void *argp1 = 0 ;
55814 int res1 = 0 ;
55815 PyObject *swig_obj[1] ;
55816
55817 if (!args) SWIG_fail;
55818 swig_obj[0] = args;
55819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55820 if (!SWIG_IsOK(res1)) {
55821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55822 }
55823 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55824 {
55825 PyThreadState* __tstate = wxPyBeginAllowThreads();
55826 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55827 wxPyEndAllowThreads(__tstate);
55828 if (PyErr_Occurred()) SWIG_fail;
55829 }
55830 resultobj = SWIG_From_int(static_cast< int >(result));
55831 return resultobj;
55832 fail:
55833 return NULL;
55834 }
55835
55836
55837 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55838 PyObject *resultobj = 0;
55839 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55840 bool result;
55841 void *argp1 = 0 ;
55842 int res1 = 0 ;
55843 PyObject *swig_obj[1] ;
55844
55845 if (!args) SWIG_fail;
55846 swig_obj[0] = args;
55847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55848 if (!SWIG_IsOK(res1)) {
55849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55850 }
55851 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55852 {
55853 PyThreadState* __tstate = wxPyBeginAllowThreads();
55854 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55855 wxPyEndAllowThreads(__tstate);
55856 if (PyErr_Occurred()) SWIG_fail;
55857 }
55858 {
55859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55860 }
55861 return resultobj;
55862 fail:
55863 return NULL;
55864 }
55865
55866
55867 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55868 PyObject *resultobj = 0;
55869 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55870 bool arg2 ;
55871 void *argp1 = 0 ;
55872 int res1 = 0 ;
55873 bool val2 ;
55874 int ecode2 = 0 ;
55875 PyObject * obj0 = 0 ;
55876 PyObject * obj1 = 0 ;
55877 char * kwnames[] = {
55878 (char *) "self",(char *) "d", NULL
55879 };
55880
55881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55883 if (!SWIG_IsOK(res1)) {
55884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55885 }
55886 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55888 if (!SWIG_IsOK(ecode2)) {
55889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55890 }
55891 arg2 = static_cast< bool >(val2);
55892 {
55893 PyThreadState* __tstate = wxPyBeginAllowThreads();
55894 (arg1)->SetDone(arg2);
55895 wxPyEndAllowThreads(__tstate);
55896 if (PyErr_Occurred()) SWIG_fail;
55897 }
55898 resultobj = SWIG_Py_Void();
55899 return resultobj;
55900 fail:
55901 return NULL;
55902 }
55903
55904
55905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55906 PyObject *resultobj = 0;
55907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55908 wxRelationship result;
55909 void *argp1 = 0 ;
55910 int res1 = 0 ;
55911 PyObject *swig_obj[1] ;
55912
55913 if (!args) SWIG_fail;
55914 swig_obj[0] = args;
55915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55916 if (!SWIG_IsOK(res1)) {
55917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55918 }
55919 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55920 {
55921 PyThreadState* __tstate = wxPyBeginAllowThreads();
55922 result = (wxRelationship)(arg1)->GetRelationship();
55923 wxPyEndAllowThreads(__tstate);
55924 if (PyErr_Occurred()) SWIG_fail;
55925 }
55926 resultobj = SWIG_From_int(static_cast< int >(result));
55927 return resultobj;
55928 fail:
55929 return NULL;
55930 }
55931
55932
55933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55934 PyObject *resultobj = 0;
55935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55936 wxRelationship arg2 ;
55937 void *argp1 = 0 ;
55938 int res1 = 0 ;
55939 int val2 ;
55940 int ecode2 = 0 ;
55941 PyObject * obj0 = 0 ;
55942 PyObject * obj1 = 0 ;
55943 char * kwnames[] = {
55944 (char *) "self",(char *) "r", NULL
55945 };
55946
55947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55949 if (!SWIG_IsOK(res1)) {
55950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55951 }
55952 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55953 ecode2 = SWIG_AsVal_int(obj1, &val2);
55954 if (!SWIG_IsOK(ecode2)) {
55955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55956 }
55957 arg2 = static_cast< wxRelationship >(val2);
55958 {
55959 PyThreadState* __tstate = wxPyBeginAllowThreads();
55960 (arg1)->SetRelationship(arg2);
55961 wxPyEndAllowThreads(__tstate);
55962 if (PyErr_Occurred()) SWIG_fail;
55963 }
55964 resultobj = SWIG_Py_Void();
55965 return resultobj;
55966 fail:
55967 return NULL;
55968 }
55969
55970
55971 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55972 PyObject *resultobj = 0;
55973 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55974 wxWindow *arg2 = (wxWindow *) 0 ;
55975 bool result;
55976 void *argp1 = 0 ;
55977 int res1 = 0 ;
55978 void *argp2 = 0 ;
55979 int res2 = 0 ;
55980 PyObject * obj0 = 0 ;
55981 PyObject * obj1 = 0 ;
55982 char * kwnames[] = {
55983 (char *) "self",(char *) "otherW", NULL
55984 };
55985
55986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55988 if (!SWIG_IsOK(res1)) {
55989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55990 }
55991 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55993 if (!SWIG_IsOK(res2)) {
55994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55995 }
55996 arg2 = reinterpret_cast< wxWindow * >(argp2);
55997 {
55998 PyThreadState* __tstate = wxPyBeginAllowThreads();
55999 result = (bool)(arg1)->ResetIfWin(arg2);
56000 wxPyEndAllowThreads(__tstate);
56001 if (PyErr_Occurred()) SWIG_fail;
56002 }
56003 {
56004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56005 }
56006 return resultobj;
56007 fail:
56008 return NULL;
56009 }
56010
56011
56012 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56013 PyObject *resultobj = 0;
56014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56015 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56016 wxWindow *arg3 = (wxWindow *) 0 ;
56017 bool result;
56018 void *argp1 = 0 ;
56019 int res1 = 0 ;
56020 void *argp2 = 0 ;
56021 int res2 = 0 ;
56022 void *argp3 = 0 ;
56023 int res3 = 0 ;
56024 PyObject * obj0 = 0 ;
56025 PyObject * obj1 = 0 ;
56026 PyObject * obj2 = 0 ;
56027 char * kwnames[] = {
56028 (char *) "self",(char *) "constraints",(char *) "win", NULL
56029 };
56030
56031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56033 if (!SWIG_IsOK(res1)) {
56034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56035 }
56036 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56037 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56038 if (!SWIG_IsOK(res2)) {
56039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56040 }
56041 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56042 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56043 if (!SWIG_IsOK(res3)) {
56044 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56045 }
56046 arg3 = reinterpret_cast< wxWindow * >(argp3);
56047 {
56048 PyThreadState* __tstate = wxPyBeginAllowThreads();
56049 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56050 wxPyEndAllowThreads(__tstate);
56051 if (PyErr_Occurred()) SWIG_fail;
56052 }
56053 {
56054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56055 }
56056 return resultobj;
56057 fail:
56058 return NULL;
56059 }
56060
56061
56062 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56063 PyObject *resultobj = 0;
56064 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56065 wxEdge arg2 ;
56066 wxWindow *arg3 = (wxWindow *) 0 ;
56067 wxWindow *arg4 = (wxWindow *) 0 ;
56068 int result;
56069 void *argp1 = 0 ;
56070 int res1 = 0 ;
56071 int val2 ;
56072 int ecode2 = 0 ;
56073 void *argp3 = 0 ;
56074 int res3 = 0 ;
56075 void *argp4 = 0 ;
56076 int res4 = 0 ;
56077 PyObject * obj0 = 0 ;
56078 PyObject * obj1 = 0 ;
56079 PyObject * obj2 = 0 ;
56080 PyObject * obj3 = 0 ;
56081 char * kwnames[] = {
56082 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56083 };
56084
56085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56087 if (!SWIG_IsOK(res1)) {
56088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56089 }
56090 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56091 ecode2 = SWIG_AsVal_int(obj1, &val2);
56092 if (!SWIG_IsOK(ecode2)) {
56093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56094 }
56095 arg2 = static_cast< wxEdge >(val2);
56096 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56097 if (!SWIG_IsOK(res3)) {
56098 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56099 }
56100 arg3 = reinterpret_cast< wxWindow * >(argp3);
56101 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56102 if (!SWIG_IsOK(res4)) {
56103 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56104 }
56105 arg4 = reinterpret_cast< wxWindow * >(argp4);
56106 {
56107 PyThreadState* __tstate = wxPyBeginAllowThreads();
56108 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56109 wxPyEndAllowThreads(__tstate);
56110 if (PyErr_Occurred()) SWIG_fail;
56111 }
56112 resultobj = SWIG_From_int(static_cast< int >(result));
56113 return resultobj;
56114 fail:
56115 return NULL;
56116 }
56117
56118
56119 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56120 PyObject *obj;
56121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56122 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56123 return SWIG_Py_Void();
56124 }
56125
56126 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56127 PyObject *resultobj = 0;
56128 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56129 wxIndividualLayoutConstraint *result = 0 ;
56130 void *argp1 = 0 ;
56131 int res1 = 0 ;
56132 PyObject *swig_obj[1] ;
56133
56134 if (!args) SWIG_fail;
56135 swig_obj[0] = args;
56136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56137 if (!SWIG_IsOK(res1)) {
56138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56139 }
56140 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56141 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56143 return resultobj;
56144 fail:
56145 return NULL;
56146 }
56147
56148
56149 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56150 PyObject *resultobj = 0;
56151 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56152 wxIndividualLayoutConstraint *result = 0 ;
56153 void *argp1 = 0 ;
56154 int res1 = 0 ;
56155 PyObject *swig_obj[1] ;
56156
56157 if (!args) SWIG_fail;
56158 swig_obj[0] = args;
56159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56160 if (!SWIG_IsOK(res1)) {
56161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56162 }
56163 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56164 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56166 return resultobj;
56167 fail:
56168 return NULL;
56169 }
56170
56171
56172 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56173 PyObject *resultobj = 0;
56174 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56175 wxIndividualLayoutConstraint *result = 0 ;
56176 void *argp1 = 0 ;
56177 int res1 = 0 ;
56178 PyObject *swig_obj[1] ;
56179
56180 if (!args) SWIG_fail;
56181 swig_obj[0] = args;
56182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56183 if (!SWIG_IsOK(res1)) {
56184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56185 }
56186 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56187 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56189 return resultobj;
56190 fail:
56191 return NULL;
56192 }
56193
56194
56195 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56196 PyObject *resultobj = 0;
56197 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56198 wxIndividualLayoutConstraint *result = 0 ;
56199 void *argp1 = 0 ;
56200 int res1 = 0 ;
56201 PyObject *swig_obj[1] ;
56202
56203 if (!args) SWIG_fail;
56204 swig_obj[0] = args;
56205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56206 if (!SWIG_IsOK(res1)) {
56207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56208 }
56209 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56210 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56212 return resultobj;
56213 fail:
56214 return NULL;
56215 }
56216
56217
56218 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56219 PyObject *resultobj = 0;
56220 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56221 wxIndividualLayoutConstraint *result = 0 ;
56222 void *argp1 = 0 ;
56223 int res1 = 0 ;
56224 PyObject *swig_obj[1] ;
56225
56226 if (!args) SWIG_fail;
56227 swig_obj[0] = args;
56228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56229 if (!SWIG_IsOK(res1)) {
56230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56231 }
56232 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56233 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56235 return resultobj;
56236 fail:
56237 return NULL;
56238 }
56239
56240
56241 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56242 PyObject *resultobj = 0;
56243 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56244 wxIndividualLayoutConstraint *result = 0 ;
56245 void *argp1 = 0 ;
56246 int res1 = 0 ;
56247 PyObject *swig_obj[1] ;
56248
56249 if (!args) SWIG_fail;
56250 swig_obj[0] = args;
56251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56252 if (!SWIG_IsOK(res1)) {
56253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56254 }
56255 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56256 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56258 return resultobj;
56259 fail:
56260 return NULL;
56261 }
56262
56263
56264 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56265 PyObject *resultobj = 0;
56266 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56267 wxIndividualLayoutConstraint *result = 0 ;
56268 void *argp1 = 0 ;
56269 int res1 = 0 ;
56270 PyObject *swig_obj[1] ;
56271
56272 if (!args) SWIG_fail;
56273 swig_obj[0] = args;
56274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56275 if (!SWIG_IsOK(res1)) {
56276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56277 }
56278 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56279 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56281 return resultobj;
56282 fail:
56283 return NULL;
56284 }
56285
56286
56287 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56288 PyObject *resultobj = 0;
56289 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56290 wxIndividualLayoutConstraint *result = 0 ;
56291 void *argp1 = 0 ;
56292 int res1 = 0 ;
56293 PyObject *swig_obj[1] ;
56294
56295 if (!args) SWIG_fail;
56296 swig_obj[0] = args;
56297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56298 if (!SWIG_IsOK(res1)) {
56299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56300 }
56301 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56302 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56304 return resultobj;
56305 fail:
56306 return NULL;
56307 }
56308
56309
56310 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56311 PyObject *resultobj = 0;
56312 wxLayoutConstraints *result = 0 ;
56313
56314 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56315 {
56316 PyThreadState* __tstate = wxPyBeginAllowThreads();
56317 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56318 wxPyEndAllowThreads(__tstate);
56319 if (PyErr_Occurred()) SWIG_fail;
56320 }
56321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56322 return resultobj;
56323 fail:
56324 return NULL;
56325 }
56326
56327
56328 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56329 PyObject *resultobj = 0;
56330 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56331 void *argp1 = 0 ;
56332 int res1 = 0 ;
56333 PyObject *swig_obj[1] ;
56334
56335 if (!args) SWIG_fail;
56336 swig_obj[0] = args;
56337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56338 if (!SWIG_IsOK(res1)) {
56339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56340 }
56341 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56342 {
56343 PyThreadState* __tstate = wxPyBeginAllowThreads();
56344 delete arg1;
56345
56346 wxPyEndAllowThreads(__tstate);
56347 if (PyErr_Occurred()) SWIG_fail;
56348 }
56349 resultobj = SWIG_Py_Void();
56350 return resultobj;
56351 fail:
56352 return NULL;
56353 }
56354
56355
56356 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56357 PyObject *resultobj = 0;
56358 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56359 wxWindow *arg2 = (wxWindow *) 0 ;
56360 int *arg3 = (int *) 0 ;
56361 bool result;
56362 void *argp1 = 0 ;
56363 int res1 = 0 ;
56364 void *argp2 = 0 ;
56365 int res2 = 0 ;
56366 int temp3 ;
56367 int res3 = SWIG_TMPOBJ ;
56368 PyObject * obj0 = 0 ;
56369 PyObject * obj1 = 0 ;
56370 char * kwnames[] = {
56371 (char *) "self",(char *) "win", NULL
56372 };
56373
56374 arg3 = &temp3;
56375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56377 if (!SWIG_IsOK(res1)) {
56378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56379 }
56380 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56382 if (!SWIG_IsOK(res2)) {
56383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56384 }
56385 arg2 = reinterpret_cast< wxWindow * >(argp2);
56386 {
56387 PyThreadState* __tstate = wxPyBeginAllowThreads();
56388 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56389 wxPyEndAllowThreads(__tstate);
56390 if (PyErr_Occurred()) SWIG_fail;
56391 }
56392 {
56393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56394 }
56395 if (SWIG_IsTmpObj(res3)) {
56396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56397 } else {
56398 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56400 }
56401 return resultobj;
56402 fail:
56403 return NULL;
56404 }
56405
56406
56407 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56408 PyObject *resultobj = 0;
56409 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56410 bool result;
56411 void *argp1 = 0 ;
56412 int res1 = 0 ;
56413 PyObject *swig_obj[1] ;
56414
56415 if (!args) SWIG_fail;
56416 swig_obj[0] = args;
56417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56418 if (!SWIG_IsOK(res1)) {
56419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56420 }
56421 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56422 {
56423 PyThreadState* __tstate = wxPyBeginAllowThreads();
56424 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56425 wxPyEndAllowThreads(__tstate);
56426 if (PyErr_Occurred()) SWIG_fail;
56427 }
56428 {
56429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56430 }
56431 return resultobj;
56432 fail:
56433 return NULL;
56434 }
56435
56436
56437 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56438 PyObject *obj;
56439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56440 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56441 return SWIG_Py_Void();
56442 }
56443
56444 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56445 return SWIG_Python_InitShadowInstance(args);
56446 }
56447
56448 static PyMethodDef SwigMethods[] = {
56449 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56450 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56451 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56452 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56454 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56455 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56456 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56457 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56458 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56460 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56473 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56474 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56475 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56477 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56478 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56479 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56480 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56481 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56482 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56483 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56485 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56491 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56492 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56493 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56494 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56495 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56496 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56497 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56499 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56507 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56508 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56509 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56514 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56515 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56517 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56519 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56521 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56523 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56525 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56527 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56528 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56530 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56532 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56534 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56536 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56537 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56538 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56539 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56555 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56559 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56560 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56561 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56562 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56563 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56564 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56565 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56566 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56568 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56569 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56570 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56575 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56576 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56577 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56578 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56579 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56586 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56593 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56594 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56595 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56596 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56598 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56599 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56600 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56602 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56603 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56604 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56605 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56608 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56611 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56614 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56617 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56620 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56623 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56626 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56629 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56635 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56637 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56638 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56639 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56646 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56649 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56650 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56651 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56652 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56653 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56654 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56655 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56656 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56658 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56659 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56660 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56662 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56663 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56664 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56665 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56670 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56671 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56672 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56673 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56674 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56675 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56678 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56679 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56680 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56681 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56682 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56683 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56685 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56686 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56687 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56688 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56689 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56690 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56691 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56692 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56693 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56694 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56695 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56696 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56701 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56707 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56708 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56709 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56710 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56712 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56715 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56718 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56721 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56722 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56723 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56726 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56727 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56728 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56732 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56733 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56734 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56738 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56743 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56744 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56745 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56746 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56747 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56748 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56749 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56756 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56757 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56759 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56760 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56761 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56767 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56768 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56770 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56771 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56772 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56773 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56774 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56775 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56776 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56777 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56779 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56780 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56781 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56782 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56783 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56784 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56785 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56786 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56788 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56797 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56814 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56815 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56830 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56831 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56832 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56833 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56836 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56838 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56840 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56842 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56844 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56847 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56848 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56849 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56850 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56852 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56854 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56862 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56866 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56867 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56868 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56869 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56870 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56873 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56876 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56877 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56879 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56880 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56881 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56882 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56883 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56884 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56885 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56886 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56887 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56888 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56889 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56890 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56891 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56892 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56893 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56894 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56895 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56896 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56897 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56898 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56899 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56900 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56901 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56902 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56903 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56904 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56905 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56906 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56907 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56908 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56909 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56910 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56911 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56912 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56913 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56914 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56916 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56917 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56918 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56919 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56920 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56921 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56922 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56926 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56927 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56930 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56931 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56932 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56933 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56934 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56935 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56936 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56937 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56938 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56940 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56942 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56944 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56945 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56946 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56947 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56948 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56949 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56951 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56952 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56953 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56955 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56956 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56957 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56959 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56960 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56961 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56962 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56963 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56965 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56966 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56967 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56968 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56969 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56970 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56971 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56972 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56973 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56974 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56975 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56976 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56977 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56978 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56979 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56980 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56981 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56982 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56984 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56985 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56986 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56987 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56988 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56989 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56990 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56991 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56992 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56993 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56994 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56995 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56996 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56997 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56998 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56999 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
57000 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
57001 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
57002 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
57003 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57004 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57005 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57006 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57007 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57008 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57009 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57010 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57011 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57012 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57013 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57014 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57015 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57016 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57017 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57018 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57019 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57020 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57021 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57022 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57023 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57024 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57025 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57026 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57027 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57028 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57029 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57030 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57031 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57032 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57033 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57034 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57035 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57036 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57037 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57038 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57039 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57040 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57041 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57042 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57043 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57044 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57045 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57046 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57047 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57048 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57049 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57050 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57051 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57052 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57053 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57054 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57055 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57056 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57057 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57058 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57059 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57061 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57062 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57063 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57064 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57065 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57066 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57067 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57068 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57069 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57070 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57071 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57072 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57073 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57074 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57075 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57076 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57077 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57078 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57079 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57080 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57081 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57082 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57083 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57084 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57085 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57086 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57087 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57088 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57089 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57090 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57091 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57092 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57093 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57094 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57095 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57096 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57097 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57098 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57099 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57100 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57101 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57102 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57103 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57104 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57105 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57106 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57109 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57110 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57111 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57112 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57113 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57114 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57116 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57117 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57120 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57121 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57123 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57124 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57129 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57130 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57131 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57133 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57135 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57136 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57138 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57139 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57140 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57141 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57142 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57143 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57144 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57145 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57146 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57147 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57149 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57150 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57151 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57152 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57153 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57154 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57156 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57158 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57160 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57161 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57162 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57165 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57166 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57167 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57168 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57169 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57170 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57171 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57172 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57173 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57174 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57175 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57176 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57177 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57178 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57180 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57181 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57182 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57183 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57184 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57185 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57186 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57187 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57190 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57193 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57194 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57195 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57196 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57197 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57198 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57199 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57200 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57201 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57202 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57204 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57205 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57206 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57207 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57208 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57209 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57210 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57211 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57212 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57215 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57216 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57217 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57218 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57220 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57221 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57222 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57223 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57224 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57226 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57228 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57229 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57231 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57232 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57233 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57234 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57236 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57237 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57238 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57240 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57241 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57242 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57243 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57244 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57245 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57246 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57247 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57248 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57249 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57250 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57251 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57252 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57254 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57255 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57257 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57258 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57259 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57260 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57262 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57263 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57264 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57266 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57268 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57269 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57270 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57272 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57273 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57274 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57275 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57276 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57277 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57279 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57281 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57283 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57285 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57286 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57287 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57288 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57289 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57290 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57291 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57292 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57293 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57294 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57295 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57296 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57298 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57300 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57302 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57304 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57306 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57307 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57308 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57309 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57310 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57311 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57312 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57313 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57315 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57316 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57319 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57320 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57321 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57322 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57323 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57324 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57325 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57326 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57328 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57329 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57330 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57331 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57332 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57333 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57334 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57335 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57336 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57338 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57339 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57340 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57341 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57342 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57343 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57344 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57346 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57347 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57348 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57350 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57353 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57354 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57355 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57356 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57357 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57359 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57360 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57362 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57363 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57364 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57365 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57367 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57368 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57369 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57370 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57371 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57372 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57373 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57374 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57375 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57376 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57378 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57381 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57382 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57383 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57385 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57387 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57389 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57391 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57392 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57395 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57405 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57406 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57410 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57411 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57412 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57413 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57414 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57415 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57416 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57417 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57418 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57419 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57420 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57421 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57422 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57423 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57424 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57426 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57429 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57430 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57434 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57435 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57436 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57439 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57440 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57441 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57442 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57445 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57446 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
57447 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57448 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57449 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57450 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57451 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57452 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57453 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57454 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57455 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57457 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57459 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57460 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57462 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57465 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57466 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57467 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57468 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57469 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57470 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57474 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57475 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57476 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57477 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57484 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57490 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57491 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57492 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57493 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57494 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57496 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57506 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57507 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57508 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57509 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57512 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57513 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57514 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57515 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57516 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57518 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57519 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57520 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57524 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57530 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57531 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57532 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57533 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57535 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57536 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57538 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57541 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57543 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57544 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57545 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57554 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57558 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57559 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57561 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57572 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57573 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57574 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57575 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57579 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57580 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57582 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57584 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57587 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57589 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57590 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57593 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57595 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57596 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57597 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57598 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57600 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57601 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57606 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57607 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57608 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57610 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57611 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57612 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57614 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57616 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57617 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57618 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57620 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57621 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57624 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57632 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57639 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57647 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57650 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57651 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57664 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57666 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57668 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57669 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57671 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57673 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57674 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57676 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57677 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57678 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57682 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57701 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57702 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57704 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57705 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57707 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57708 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57709 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57711 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57712 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57715 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57716 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57718 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57719 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57721 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57724 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57725 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57727 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57729 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57731 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57732 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57734 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57735 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57738 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57740 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57742 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57744 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57747 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57749 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57750 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57751 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57753 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57754 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57755 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57757 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57759 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57760 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57763 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57764 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57768 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57772 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57773 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57775 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57779 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57781 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57783 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57784 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57785 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57786 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57790 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57791 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57792 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57793 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57795 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57796 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57801 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57802 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57803 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57804 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57805 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57807 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57809 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57811 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57812 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57814 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57816 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57819 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57820 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57821 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57823 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57824 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57825 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57838 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57844 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57845 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57846 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57847 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57848 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57849 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57855 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57856 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57860 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57861 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57863 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57864 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57866 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57868 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57869 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57871 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57872 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57873 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57879 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57880 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57881 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57882 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57883 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57884 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57891 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57893 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57894 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57895 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57896 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57897 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57898 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57900 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57904 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57905 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57906 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57907 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57908 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57909 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57910 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57912 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57913 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57914 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57920 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57921 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57922 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57924 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57925 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57926 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57932 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57933 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57934 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57935 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57936 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57940 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57941 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57946 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57947 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57949 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57950 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57955 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57957 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57958 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57959 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57960 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57961 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57966 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57967 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57976 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57977 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57978 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57979 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57980 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57982 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57984 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57985 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57986 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57987 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57989 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57990 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57994 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57995 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57996 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57997 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57998 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57999 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
58000 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
58001 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
58002 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
58003 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
58004 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58005 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
58006 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58007 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58008 { NULL, NULL, 0, NULL }
58009 };
58010
58011
58012 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58013
58014 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58015 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58016 }
58017 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58018 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58019 }
58020 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58021 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58022 }
58023 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58024 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58025 }
58026 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58027 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58028 }
58029 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58030 return (void *)((wxSizer *) ((wxGridSizer *) x));
58031 }
58032 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58033 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58034 }
58035 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58036 return (void *)((wxSizer *) ((wxPySizer *) x));
58037 }
58038 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58039 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58040 }
58041 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58042 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58043 }
58044 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58045 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58046 }
58047 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58048 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58049 }
58050 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58051 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58052 }
58053 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58054 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58055 }
58056 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58057 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58058 }
58059 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58060 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58061 }
58062 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58063 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58064 }
58065 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58066 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58067 }
58068 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58069 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58070 }
58071 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58072 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58073 }
58074 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58075 return (void *)((wxEvent *) ((wxPyEvent *) x));
58076 }
58077 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58078 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58079 }
58080 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58081 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58082 }
58083 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58084 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58085 }
58086 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58087 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58088 }
58089 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58090 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58091 }
58092 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58093 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58094 }
58095 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58096 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58097 }
58098 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58099 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58100 }
58101 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58102 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58103 }
58104 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58105 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58106 }
58107 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58108 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58109 }
58110 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58111 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58112 }
58113 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58114 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58115 }
58116 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58117 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58118 }
58119 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58120 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58121 }
58122 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58123 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58124 }
58125 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58126 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58127 }
58128 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58129 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58130 }
58131 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58132 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58133 }
58134 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58135 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58136 }
58137 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58138 return (void *)((wxEvent *) ((wxShowEvent *) x));
58139 }
58140 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58141 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58142 }
58143 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58144 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58145 }
58146 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58147 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58148 }
58149 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58150 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58151 }
58152 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58153 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58154 }
58155 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58156 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58157 }
58158 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58159 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58160 }
58161 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58162 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58163 }
58164 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58165 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58166 }
58167 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58168 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58169 }
58170 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58171 return (void *)((wxControl *) ((wxControlWithItems *) x));
58172 }
58173 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58174 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58175 }
58176 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58177 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58178 }
58179 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58180 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58181 }
58182 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58183 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58184 }
58185 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58186 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58187 }
58188 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58189 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58190 }
58191 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58192 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58193 }
58194 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58195 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58196 }
58197 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58198 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58199 }
58200 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58201 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58202 }
58203 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58204 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58205 }
58206 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58207 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58208 }
58209 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58210 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58211 }
58212 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58213 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58214 }
58215 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58216 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58217 }
58218 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58219 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58220 }
58221 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58222 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58223 }
58224 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58225 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58226 }
58227 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58228 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58229 }
58230 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58231 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58232 }
58233 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58234 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58235 }
58236 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58237 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58238 }
58239 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58240 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58241 }
58242 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58243 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58244 }
58245 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58246 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58247 }
58248 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58249 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58250 }
58251 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58252 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58253 }
58254 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58255 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58256 }
58257 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58258 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58259 }
58260 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58261 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58262 }
58263 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58264 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58265 }
58266 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58267 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58268 }
58269 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58270 return (void *)((wxObject *) ((wxSizerItem *) x));
58271 }
58272 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58273 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58274 }
58275 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58276 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58277 }
58278 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58279 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58280 }
58281 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58282 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58283 }
58284 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58285 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58286 }
58287 static void *_p_wxSizerTo_p_wxObject(void *x) {
58288 return (void *)((wxObject *) ((wxSizer *) x));
58289 }
58290 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58291 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58292 }
58293 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58294 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58295 }
58296 static void *_p_wxEventTo_p_wxObject(void *x) {
58297 return (void *)((wxObject *) ((wxEvent *) x));
58298 }
58299 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58300 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58301 }
58302 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58303 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58304 }
58305 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58306 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58307 }
58308 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58309 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58310 }
58311 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58312 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58313 }
58314 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58315 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58316 }
58317 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58318 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58319 }
58320 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58321 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58322 }
58323 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58324 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58325 }
58326 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58327 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58328 }
58329 static void *_p_wxControlTo_p_wxObject(void *x) {
58330 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58331 }
58332 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58333 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58334 }
58335 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58336 return (void *)((wxObject *) ((wxFSFile *) x));
58337 }
58338 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58339 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58340 }
58341 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58342 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58343 }
58344 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58346 }
58347 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58348 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58349 }
58350 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58351 return (void *)((wxObject *) ((wxMenuItem *) x));
58352 }
58353 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58354 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58355 }
58356 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58357 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58358 }
58359 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58360 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58361 }
58362 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58363 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58364 }
58365 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58366 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58367 }
58368 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58369 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58370 }
58371 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58372 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58373 }
58374 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58375 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58376 }
58377 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58378 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58379 }
58380 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58381 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58382 }
58383 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58384 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58385 }
58386 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58387 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58388 }
58389 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58390 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58391 }
58392 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58393 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58394 }
58395 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58396 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58397 }
58398 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58399 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58400 }
58401 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58402 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58403 }
58404 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58405 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58406 }
58407 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58408 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58409 }
58410 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58411 return (void *)((wxObject *) ((wxImageHandler *) x));
58412 }
58413 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58414 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58415 }
58416 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58417 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58418 }
58419 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58420 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58421 }
58422 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58423 return (void *)((wxObject *) ((wxEvtHandler *) x));
58424 }
58425 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58426 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58427 }
58428 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58429 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58430 }
58431 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58432 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58433 }
58434 static void *_p_wxImageTo_p_wxObject(void *x) {
58435 return (void *)((wxObject *) ((wxImage *) x));
58436 }
58437 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58438 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58439 }
58440 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58442 }
58443 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58444 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58445 }
58446 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58447 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58448 }
58449 static void *_p_wxWindowTo_p_wxObject(void *x) {
58450 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58451 }
58452 static void *_p_wxMenuTo_p_wxObject(void *x) {
58453 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58454 }
58455 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58456 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58457 }
58458 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58459 return (void *)((wxObject *) ((wxFileSystem *) x));
58460 }
58461 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58462 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58463 }
58464 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58465 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58466 }
58467 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58468 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58469 }
58470 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58471 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58472 }
58473 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58474 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58475 }
58476 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58477 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58478 }
58479 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58480 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58481 }
58482 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58483 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58484 }
58485 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58486 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58487 }
58488 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58489 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58490 }
58491 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58492 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58493 }
58494 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58495 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58496 }
58497 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58498 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58499 }
58500 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58501 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58502 }
58503 static void *_p_wxControlTo_p_wxWindow(void *x) {
58504 return (void *)((wxWindow *) ((wxControl *) x));
58505 }
58506 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58507 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58508 }
58509 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58510 return (void *)((wxWindow *) ((wxMenuBar *) x));
58511 }
58512 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58513 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58514 }
58515 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58516 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58517 }
58518 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58519 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58520 }
58521 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58522 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58523 }
58524 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58525 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58526 }
58527 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58528 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58529 }
58530 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58531 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58532 }
58533 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58534 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58535 }
58536 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58537 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58538 }
58539 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58540 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58541 }
58542 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58543 return (void *)((wxValidator *) ((wxPyValidator *) x));
58544 }
58545 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58547 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};
58548 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58654 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58655 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58656 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58657 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58658 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58659 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58660 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58661 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58662 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58663 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58664 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58665 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58666 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58667 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58668 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58669 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58670 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58671 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58672 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58673 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58674 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58675 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58676 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58677 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58678 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58679 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58680
58681 static swig_type_info *swig_type_initial[] = {
58682 &_swigt__p_buffer,
58683 &_swigt__p_char,
58684 &_swigt__p_form_ops_t,
58685 &_swigt__p_int,
58686 &_swigt__p_long,
58687 &_swigt__p_unsigned_char,
58688 &_swigt__p_unsigned_int,
58689 &_swigt__p_unsigned_long,
58690 &_swigt__p_wxANIHandler,
58691 &_swigt__p_wxAcceleratorEntry,
58692 &_swigt__p_wxAcceleratorTable,
58693 &_swigt__p_wxActivateEvent,
58694 &_swigt__p_wxAppTraits,
58695 &_swigt__p_wxArrayString,
58696 &_swigt__p_wxBMPHandler,
58697 &_swigt__p_wxBitmap,
58698 &_swigt__p_wxBoxSizer,
58699 &_swigt__p_wxButton,
58700 &_swigt__p_wxCURHandler,
58701 &_swigt__p_wxCaret,
58702 &_swigt__p_wxChildFocusEvent,
58703 &_swigt__p_wxClipboardTextEvent,
58704 &_swigt__p_wxCloseEvent,
58705 &_swigt__p_wxColour,
58706 &_swigt__p_wxCommandEvent,
58707 &_swigt__p_wxContextMenuEvent,
58708 &_swigt__p_wxControl,
58709 &_swigt__p_wxControlWithItems,
58710 &_swigt__p_wxCursor,
58711 &_swigt__p_wxDC,
58712 &_swigt__p_wxDateEvent,
58713 &_swigt__p_wxDateTime,
58714 &_swigt__p_wxDisplayChangedEvent,
58715 &_swigt__p_wxDouble,
58716 &_swigt__p_wxDropFilesEvent,
58717 &_swigt__p_wxDuplexMode,
58718 &_swigt__p_wxEraseEvent,
58719 &_swigt__p_wxEvent,
58720 &_swigt__p_wxEventLoop,
58721 &_swigt__p_wxEventLoopActivator,
58722 &_swigt__p_wxEvtHandler,
58723 &_swigt__p_wxFSFile,
58724 &_swigt__p_wxFileSystem,
58725 &_swigt__p_wxFileSystemHandler,
58726 &_swigt__p_wxFlexGridSizer,
58727 &_swigt__p_wxFocusEvent,
58728 &_swigt__p_wxFont,
58729 &_swigt__p_wxFrame,
58730 &_swigt__p_wxGBPosition,
58731 &_swigt__p_wxGBSizerItem,
58732 &_swigt__p_wxGBSpan,
58733 &_swigt__p_wxGIFHandler,
58734 &_swigt__p_wxGridBagSizer,
58735 &_swigt__p_wxGridSizer,
58736 &_swigt__p_wxHelpEvent__Origin,
58737 &_swigt__p_wxICOHandler,
58738 &_swigt__p_wxIconizeEvent,
58739 &_swigt__p_wxIdleEvent,
58740 &_swigt__p_wxImage,
58741 &_swigt__p_wxImageHandler,
58742 &_swigt__p_wxImageHistogram,
58743 &_swigt__p_wxImage_HSVValue,
58744 &_swigt__p_wxImage_RGBValue,
58745 &_swigt__p_wxIndividualLayoutConstraint,
58746 &_swigt__p_wxInitDialogEvent,
58747 &_swigt__p_wxInputStream,
58748 &_swigt__p_wxInternetFSHandler,
58749 &_swigt__p_wxItemContainer,
58750 &_swigt__p_wxJPEGHandler,
58751 &_swigt__p_wxKeyEvent,
58752 &_swigt__p_wxLayoutConstraints,
58753 &_swigt__p_wxMaximizeEvent,
58754 &_swigt__p_wxMemoryFSHandler,
58755 &_swigt__p_wxMenu,
58756 &_swigt__p_wxMenuBar,
58757 &_swigt__p_wxMenuBarBase,
58758 &_swigt__p_wxMenuEvent,
58759 &_swigt__p_wxMenuItem,
58760 &_swigt__p_wxMouseCaptureChangedEvent,
58761 &_swigt__p_wxMouseCaptureLostEvent,
58762 &_swigt__p_wxMouseEvent,
58763 &_swigt__p_wxMoveEvent,
58764 &_swigt__p_wxNavigationKeyEvent,
58765 &_swigt__p_wxNcPaintEvent,
58766 &_swigt__p_wxNotifyEvent,
58767 &_swigt__p_wxObject,
58768 &_swigt__p_wxOutputStream,
58769 &_swigt__p_wxPCXHandler,
58770 &_swigt__p_wxPNGHandler,
58771 &_swigt__p_wxPNMHandler,
58772 &_swigt__p_wxPaintEvent,
58773 &_swigt__p_wxPaletteChangedEvent,
58774 &_swigt__p_wxPaperSize,
58775 &_swigt__p_wxPoint,
58776 &_swigt__p_wxPoint2D,
58777 &_swigt__p_wxPropagateOnce,
58778 &_swigt__p_wxPropagationDisabler,
58779 &_swigt__p_wxPyApp,
58780 &_swigt__p_wxPyCommandEvent,
58781 &_swigt__p_wxPyDropTarget,
58782 &_swigt__p_wxPyEvent,
58783 &_swigt__p_wxPyFileSystemHandler,
58784 &_swigt__p_wxPyImageHandler,
58785 &_swigt__p_wxPyInputStream,
58786 &_swigt__p_wxPySizer,
58787 &_swigt__p_wxPyValidator,
58788 &_swigt__p_wxQuantize,
58789 &_swigt__p_wxQueryNewPaletteEvent,
58790 &_swigt__p_wxRealPoint,
58791 &_swigt__p_wxRect,
58792 &_swigt__p_wxRect2D,
58793 &_swigt__p_wxRegion,
58794 &_swigt__p_wxScrollEvent,
58795 &_swigt__p_wxScrollWinEvent,
58796 &_swigt__p_wxSetCursorEvent,
58797 &_swigt__p_wxShowEvent,
58798 &_swigt__p_wxSize,
58799 &_swigt__p_wxSizeEvent,
58800 &_swigt__p_wxSizer,
58801 &_swigt__p_wxSizerItem,
58802 &_swigt__p_wxStaticBox,
58803 &_swigt__p_wxStaticBoxSizer,
58804 &_swigt__p_wxStdDialogButtonSizer,
58805 &_swigt__p_wxSysColourChangedEvent,
58806 &_swigt__p_wxTGAHandler,
58807 &_swigt__p_wxTIFFHandler,
58808 &_swigt__p_wxToolTip,
58809 &_swigt__p_wxUpdateUIEvent,
58810 &_swigt__p_wxValidator,
58811 &_swigt__p_wxVisualAttributes,
58812 &_swigt__p_wxWindow,
58813 &_swigt__p_wxWindowCreateEvent,
58814 &_swigt__p_wxWindowDestroyEvent,
58815 &_swigt__p_wxXPMHandler,
58816 &_swigt__p_wxZipFSHandler,
58817 };
58818
58819 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58833 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}};
58834 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58835 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}};
58836 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58837 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}};
58838 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58843 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}};
58844 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58845 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}};
58846 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58856 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}};
58857 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58859 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}};
58860 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58862 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}};
58863 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}};
58864 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58872 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}};
58873 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58874 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}};
58875 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58879 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58886 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}};
58887 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58896 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58897 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58898 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
58905 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58906 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58912 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58913 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58914 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58921 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58922 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58923 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58924 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58928 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58929 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58930 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58931 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58932 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58933 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58934 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58935 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58936 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58937 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}};
58938 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}};
58939 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58940 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58941 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58942 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58943 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58944 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58945 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58946 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58947 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}};
58948 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58949 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}};
58950 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58951 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58952 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58953 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58954
58955 static swig_cast_info *swig_cast_initial[] = {
58956 _swigc__p_buffer,
58957 _swigc__p_char,
58958 _swigc__p_form_ops_t,
58959 _swigc__p_int,
58960 _swigc__p_long,
58961 _swigc__p_unsigned_char,
58962 _swigc__p_unsigned_int,
58963 _swigc__p_unsigned_long,
58964 _swigc__p_wxANIHandler,
58965 _swigc__p_wxAcceleratorEntry,
58966 _swigc__p_wxAcceleratorTable,
58967 _swigc__p_wxActivateEvent,
58968 _swigc__p_wxAppTraits,
58969 _swigc__p_wxArrayString,
58970 _swigc__p_wxBMPHandler,
58971 _swigc__p_wxBitmap,
58972 _swigc__p_wxBoxSizer,
58973 _swigc__p_wxButton,
58974 _swigc__p_wxCURHandler,
58975 _swigc__p_wxCaret,
58976 _swigc__p_wxChildFocusEvent,
58977 _swigc__p_wxClipboardTextEvent,
58978 _swigc__p_wxCloseEvent,
58979 _swigc__p_wxColour,
58980 _swigc__p_wxCommandEvent,
58981 _swigc__p_wxContextMenuEvent,
58982 _swigc__p_wxControl,
58983 _swigc__p_wxControlWithItems,
58984 _swigc__p_wxCursor,
58985 _swigc__p_wxDC,
58986 _swigc__p_wxDateEvent,
58987 _swigc__p_wxDateTime,
58988 _swigc__p_wxDisplayChangedEvent,
58989 _swigc__p_wxDouble,
58990 _swigc__p_wxDropFilesEvent,
58991 _swigc__p_wxDuplexMode,
58992 _swigc__p_wxEraseEvent,
58993 _swigc__p_wxEvent,
58994 _swigc__p_wxEventLoop,
58995 _swigc__p_wxEventLoopActivator,
58996 _swigc__p_wxEvtHandler,
58997 _swigc__p_wxFSFile,
58998 _swigc__p_wxFileSystem,
58999 _swigc__p_wxFileSystemHandler,
59000 _swigc__p_wxFlexGridSizer,
59001 _swigc__p_wxFocusEvent,
59002 _swigc__p_wxFont,
59003 _swigc__p_wxFrame,
59004 _swigc__p_wxGBPosition,
59005 _swigc__p_wxGBSizerItem,
59006 _swigc__p_wxGBSpan,
59007 _swigc__p_wxGIFHandler,
59008 _swigc__p_wxGridBagSizer,
59009 _swigc__p_wxGridSizer,
59010 _swigc__p_wxHelpEvent__Origin,
59011 _swigc__p_wxICOHandler,
59012 _swigc__p_wxIconizeEvent,
59013 _swigc__p_wxIdleEvent,
59014 _swigc__p_wxImage,
59015 _swigc__p_wxImageHandler,
59016 _swigc__p_wxImageHistogram,
59017 _swigc__p_wxImage_HSVValue,
59018 _swigc__p_wxImage_RGBValue,
59019 _swigc__p_wxIndividualLayoutConstraint,
59020 _swigc__p_wxInitDialogEvent,
59021 _swigc__p_wxInputStream,
59022 _swigc__p_wxInternetFSHandler,
59023 _swigc__p_wxItemContainer,
59024 _swigc__p_wxJPEGHandler,
59025 _swigc__p_wxKeyEvent,
59026 _swigc__p_wxLayoutConstraints,
59027 _swigc__p_wxMaximizeEvent,
59028 _swigc__p_wxMemoryFSHandler,
59029 _swigc__p_wxMenu,
59030 _swigc__p_wxMenuBar,
59031 _swigc__p_wxMenuBarBase,
59032 _swigc__p_wxMenuEvent,
59033 _swigc__p_wxMenuItem,
59034 _swigc__p_wxMouseCaptureChangedEvent,
59035 _swigc__p_wxMouseCaptureLostEvent,
59036 _swigc__p_wxMouseEvent,
59037 _swigc__p_wxMoveEvent,
59038 _swigc__p_wxNavigationKeyEvent,
59039 _swigc__p_wxNcPaintEvent,
59040 _swigc__p_wxNotifyEvent,
59041 _swigc__p_wxObject,
59042 _swigc__p_wxOutputStream,
59043 _swigc__p_wxPCXHandler,
59044 _swigc__p_wxPNGHandler,
59045 _swigc__p_wxPNMHandler,
59046 _swigc__p_wxPaintEvent,
59047 _swigc__p_wxPaletteChangedEvent,
59048 _swigc__p_wxPaperSize,
59049 _swigc__p_wxPoint,
59050 _swigc__p_wxPoint2D,
59051 _swigc__p_wxPropagateOnce,
59052 _swigc__p_wxPropagationDisabler,
59053 _swigc__p_wxPyApp,
59054 _swigc__p_wxPyCommandEvent,
59055 _swigc__p_wxPyDropTarget,
59056 _swigc__p_wxPyEvent,
59057 _swigc__p_wxPyFileSystemHandler,
59058 _swigc__p_wxPyImageHandler,
59059 _swigc__p_wxPyInputStream,
59060 _swigc__p_wxPySizer,
59061 _swigc__p_wxPyValidator,
59062 _swigc__p_wxQuantize,
59063 _swigc__p_wxQueryNewPaletteEvent,
59064 _swigc__p_wxRealPoint,
59065 _swigc__p_wxRect,
59066 _swigc__p_wxRect2D,
59067 _swigc__p_wxRegion,
59068 _swigc__p_wxScrollEvent,
59069 _swigc__p_wxScrollWinEvent,
59070 _swigc__p_wxSetCursorEvent,
59071 _swigc__p_wxShowEvent,
59072 _swigc__p_wxSize,
59073 _swigc__p_wxSizeEvent,
59074 _swigc__p_wxSizer,
59075 _swigc__p_wxSizerItem,
59076 _swigc__p_wxStaticBox,
59077 _swigc__p_wxStaticBoxSizer,
59078 _swigc__p_wxStdDialogButtonSizer,
59079 _swigc__p_wxSysColourChangedEvent,
59080 _swigc__p_wxTGAHandler,
59081 _swigc__p_wxTIFFHandler,
59082 _swigc__p_wxToolTip,
59083 _swigc__p_wxUpdateUIEvent,
59084 _swigc__p_wxValidator,
59085 _swigc__p_wxVisualAttributes,
59086 _swigc__p_wxWindow,
59087 _swigc__p_wxWindowCreateEvent,
59088 _swigc__p_wxWindowDestroyEvent,
59089 _swigc__p_wxXPMHandler,
59090 _swigc__p_wxZipFSHandler,
59091 };
59092
59093
59094 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59095
59096 static swig_const_info swig_const_table[] = {
59097 {0, 0, 0, 0.0, 0, 0}};
59098
59099 #ifdef __cplusplus
59100 }
59101 #endif
59102 /* -----------------------------------------------------------------------------
59103 * Type initialization:
59104 * This problem is tough by the requirement that no dynamic
59105 * memory is used. Also, since swig_type_info structures store pointers to
59106 * swig_cast_info structures and swig_cast_info structures store pointers back
59107 * to swig_type_info structures, we need some lookup code at initialization.
59108 * The idea is that swig generates all the structures that are needed.
59109 * The runtime then collects these partially filled structures.
59110 * The SWIG_InitializeModule function takes these initial arrays out of
59111 * swig_module, and does all the lookup, filling in the swig_module.types
59112 * array with the correct data and linking the correct swig_cast_info
59113 * structures together.
59114 *
59115 * The generated swig_type_info structures are assigned staticly to an initial
59116 * array. We just loop though that array, and handle each type individually.
59117 * First we lookup if this type has been already loaded, and if so, use the
59118 * loaded structure instead of the generated one. Then we have to fill in the
59119 * cast linked list. The cast data is initially stored in something like a
59120 * two-dimensional array. Each row corresponds to a type (there are the same
59121 * number of rows as there are in the swig_type_initial array). Each entry in
59122 * a column is one of the swig_cast_info structures for that type.
59123 * The cast_initial array is actually an array of arrays, because each row has
59124 * a variable number of columns. So to actually build the cast linked list,
59125 * we find the array of casts associated with the type, and loop through it
59126 * adding the casts to the list. The one last trick we need to do is making
59127 * sure the type pointer in the swig_cast_info struct is correct.
59128 *
59129 * First off, we lookup the cast->type name to see if it is already loaded.
59130 * There are three cases to handle:
59131 * 1) If the cast->type has already been loaded AND the type we are adding
59132 * casting info to has not been loaded (it is in this module), THEN we
59133 * replace the cast->type pointer with the type pointer that has already
59134 * been loaded.
59135 * 2) If BOTH types (the one we are adding casting info to, and the
59136 * cast->type) are loaded, THEN the cast info has already been loaded by
59137 * the previous module so we just ignore it.
59138 * 3) Finally, if cast->type has not already been loaded, then we add that
59139 * swig_cast_info to the linked list (because the cast->type) pointer will
59140 * be correct.
59141 * ----------------------------------------------------------------------------- */
59142
59143 #ifdef __cplusplus
59144 extern "C" {
59145 #if 0
59146 } /* c-mode */
59147 #endif
59148 #endif
59149
59150 #if 0
59151 #define SWIGRUNTIME_DEBUG
59152 #endif
59153
59154 SWIGRUNTIME void
59155 SWIG_InitializeModule(void *clientdata) {
59156 size_t i;
59157 swig_module_info *module_head;
59158 static int init_run = 0;
59159
59160 clientdata = clientdata;
59161
59162 if (init_run) return;
59163 init_run = 1;
59164
59165 /* Initialize the swig_module */
59166 swig_module.type_initial = swig_type_initial;
59167 swig_module.cast_initial = swig_cast_initial;
59168
59169 /* Try and load any already created modules */
59170 module_head = SWIG_GetModule(clientdata);
59171 if (module_head) {
59172 swig_module.next = module_head->next;
59173 module_head->next = &swig_module;
59174 } else {
59175 /* This is the first module loaded */
59176 swig_module.next = &swig_module;
59177 SWIG_SetModule(clientdata, &swig_module);
59178 }
59179
59180 /* Now work on filling in swig_module.types */
59181 #ifdef SWIGRUNTIME_DEBUG
59182 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59183 #endif
59184 for (i = 0; i < swig_module.size; ++i) {
59185 swig_type_info *type = 0;
59186 swig_type_info *ret;
59187 swig_cast_info *cast;
59188
59189 #ifdef SWIGRUNTIME_DEBUG
59190 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59191 #endif
59192
59193 /* if there is another module already loaded */
59194 if (swig_module.next != &swig_module) {
59195 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59196 }
59197 if (type) {
59198 /* Overwrite clientdata field */
59199 #ifdef SWIGRUNTIME_DEBUG
59200 printf("SWIG_InitializeModule: found type %s\n", type->name);
59201 #endif
59202 if (swig_module.type_initial[i]->clientdata) {
59203 type->clientdata = swig_module.type_initial[i]->clientdata;
59204 #ifdef SWIGRUNTIME_DEBUG
59205 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59206 #endif
59207 }
59208 } else {
59209 type = swig_module.type_initial[i];
59210 }
59211
59212 /* Insert casting types */
59213 cast = swig_module.cast_initial[i];
59214 while (cast->type) {
59215 /* Don't need to add information already in the list */
59216 ret = 0;
59217 #ifdef SWIGRUNTIME_DEBUG
59218 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59219 #endif
59220 if (swig_module.next != &swig_module) {
59221 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59222 #ifdef SWIGRUNTIME_DEBUG
59223 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59224 #endif
59225 }
59226 if (ret) {
59227 if (type == swig_module.type_initial[i]) {
59228 #ifdef SWIGRUNTIME_DEBUG
59229 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59230 #endif
59231 cast->type = ret;
59232 ret = 0;
59233 } else {
59234 /* Check for casting already in the list */
59235 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59236 #ifdef SWIGRUNTIME_DEBUG
59237 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59238 #endif
59239 if (!ocast) ret = 0;
59240 }
59241 }
59242
59243 if (!ret) {
59244 #ifdef SWIGRUNTIME_DEBUG
59245 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59246 #endif
59247 if (type->cast) {
59248 type->cast->prev = cast;
59249 cast->next = type->cast;
59250 }
59251 type->cast = cast;
59252 }
59253 cast++;
59254 }
59255 /* Set entry in modules->types array equal to the type */
59256 swig_module.types[i] = type;
59257 }
59258 swig_module.types[i] = 0;
59259
59260 #ifdef SWIGRUNTIME_DEBUG
59261 printf("**** SWIG_InitializeModule: Cast List ******\n");
59262 for (i = 0; i < swig_module.size; ++i) {
59263 int j = 0;
59264 swig_cast_info *cast = swig_module.cast_initial[i];
59265 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59266 while (cast->type) {
59267 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59268 cast++;
59269 ++j;
59270 }
59271 printf("---- Total casts: %d\n",j);
59272 }
59273 printf("**** SWIG_InitializeModule: Cast List ******\n");
59274 #endif
59275 }
59276
59277 /* This function will propagate the clientdata field of type to
59278 * any new swig_type_info structures that have been added into the list
59279 * of equivalent types. It is like calling
59280 * SWIG_TypeClientData(type, clientdata) a second time.
59281 */
59282 SWIGRUNTIME void
59283 SWIG_PropagateClientData(void) {
59284 size_t i;
59285 swig_cast_info *equiv;
59286 static int init_run = 0;
59287
59288 if (init_run) return;
59289 init_run = 1;
59290
59291 for (i = 0; i < swig_module.size; i++) {
59292 if (swig_module.types[i]->clientdata) {
59293 equiv = swig_module.types[i]->cast;
59294 while (equiv) {
59295 if (!equiv->converter) {
59296 if (equiv->type && !equiv->type->clientdata)
59297 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59298 }
59299 equiv = equiv->next;
59300 }
59301 }
59302 }
59303 }
59304
59305 #ifdef __cplusplus
59306 #if 0
59307 {
59308 /* c-mode */
59309 #endif
59310 }
59311 #endif
59312
59313
59314
59315 #ifdef __cplusplus
59316 extern "C" {
59317 #endif
59318
59319 /* Python-specific SWIG API */
59320 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59321 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59322 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59323
59324 /* -----------------------------------------------------------------------------
59325 * global variable support code.
59326 * ----------------------------------------------------------------------------- */
59327
59328 typedef struct swig_globalvar {
59329 char *name; /* Name of global variable */
59330 PyObject *(*get_attr)(void); /* Return the current value */
59331 int (*set_attr)(PyObject *); /* Set the value */
59332 struct swig_globalvar *next;
59333 } swig_globalvar;
59334
59335 typedef struct swig_varlinkobject {
59336 PyObject_HEAD
59337 swig_globalvar *vars;
59338 } swig_varlinkobject;
59339
59340 SWIGINTERN PyObject *
59341 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59342 return PyString_FromString("<Swig global variables>");
59343 }
59344
59345 SWIGINTERN PyObject *
59346 swig_varlink_str(swig_varlinkobject *v) {
59347 PyObject *str = PyString_FromString("(");
59348 swig_globalvar *var;
59349 for (var = v->vars; var; var=var->next) {
59350 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59351 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59352 }
59353 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59354 return str;
59355 }
59356
59357 SWIGINTERN int
59358 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59359 PyObject *str = swig_varlink_str(v);
59360 fprintf(fp,"Swig global variables ");
59361 fprintf(fp,"%s\n", PyString_AsString(str));
59362 Py_DECREF(str);
59363 return 0;
59364 }
59365
59366 SWIGINTERN void
59367 swig_varlink_dealloc(swig_varlinkobject *v) {
59368 swig_globalvar *var = v->vars;
59369 while (var) {
59370 swig_globalvar *n = var->next;
59371 free(var->name);
59372 free(var);
59373 var = n;
59374 }
59375 }
59376
59377 SWIGINTERN PyObject *
59378 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59379 PyObject *res = NULL;
59380 swig_globalvar *var = v->vars;
59381 while (var) {
59382 if (strcmp(var->name,n) == 0) {
59383 res = (*var->get_attr)();
59384 break;
59385 }
59386 var = var->next;
59387 }
59388 if (res == NULL && !PyErr_Occurred()) {
59389 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59390 }
59391 return res;
59392 }
59393
59394 SWIGINTERN int
59395 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59396 int res = 1;
59397 swig_globalvar *var = v->vars;
59398 while (var) {
59399 if (strcmp(var->name,n) == 0) {
59400 res = (*var->set_attr)(p);
59401 break;
59402 }
59403 var = var->next;
59404 }
59405 if (res == 1 && !PyErr_Occurred()) {
59406 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59407 }
59408 return res;
59409 }
59410
59411 SWIGINTERN PyTypeObject*
59412 swig_varlink_type(void) {
59413 static char varlink__doc__[] = "Swig var link object";
59414 static PyTypeObject varlink_type;
59415 static int type_init = 0;
59416 if (!type_init) {
59417 const PyTypeObject tmp
59418 = {
59419 PyObject_HEAD_INIT(NULL)
59420 0, /* Number of items in variable part (ob_size) */
59421 (char *)"swigvarlink", /* Type name (tp_name) */
59422 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59423 0, /* Itemsize (tp_itemsize) */
59424 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59425 (printfunc) swig_varlink_print, /* Print (tp_print) */
59426 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59427 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59428 0, /* tp_compare */
59429 (reprfunc) swig_varlink_repr, /* tp_repr */
59430 0, /* tp_as_number */
59431 0, /* tp_as_sequence */
59432 0, /* tp_as_mapping */
59433 0, /* tp_hash */
59434 0, /* tp_call */
59435 (reprfunc)swig_varlink_str, /* tp_str */
59436 0, /* tp_getattro */
59437 0, /* tp_setattro */
59438 0, /* tp_as_buffer */
59439 0, /* tp_flags */
59440 varlink__doc__, /* tp_doc */
59441 0, /* tp_traverse */
59442 0, /* tp_clear */
59443 0, /* tp_richcompare */
59444 0, /* tp_weaklistoffset */
59445 #if PY_VERSION_HEX >= 0x02020000
59446 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59447 #endif
59448 #if PY_VERSION_HEX >= 0x02030000
59449 0, /* tp_del */
59450 #endif
59451 #ifdef COUNT_ALLOCS
59452 0,0,0,0 /* tp_alloc -> tp_next */
59453 #endif
59454 };
59455 varlink_type = tmp;
59456 varlink_type.ob_type = &PyType_Type;
59457 type_init = 1;
59458 }
59459 return &varlink_type;
59460 }
59461
59462 /* Create a variable linking object for use later */
59463 SWIGINTERN PyObject *
59464 SWIG_Python_newvarlink(void) {
59465 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59466 if (result) {
59467 result->vars = 0;
59468 }
59469 return ((PyObject*) result);
59470 }
59471
59472 SWIGINTERN void
59473 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59474 swig_varlinkobject *v = (swig_varlinkobject *) p;
59475 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59476 if (gv) {
59477 size_t size = strlen(name)+1;
59478 gv->name = (char *)malloc(size);
59479 if (gv->name) {
59480 strncpy(gv->name,name,size);
59481 gv->get_attr = get_attr;
59482 gv->set_attr = set_attr;
59483 gv->next = v->vars;
59484 }
59485 }
59486 v->vars = gv;
59487 }
59488
59489 SWIGINTERN PyObject *
59490 SWIG_globals() {
59491 static PyObject *_SWIG_globals = 0;
59492 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59493 return _SWIG_globals;
59494 }
59495
59496 /* -----------------------------------------------------------------------------
59497 * constants/methods manipulation
59498 * ----------------------------------------------------------------------------- */
59499
59500 /* Install Constants */
59501 SWIGINTERN void
59502 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59503 PyObject *obj = 0;
59504 size_t i;
59505 for (i = 0; constants[i].type; ++i) {
59506 switch(constants[i].type) {
59507 case SWIG_PY_POINTER:
59508 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59509 break;
59510 case SWIG_PY_BINARY:
59511 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59512 break;
59513 default:
59514 obj = 0;
59515 break;
59516 }
59517 if (obj) {
59518 PyDict_SetItemString(d, constants[i].name, obj);
59519 Py_DECREF(obj);
59520 }
59521 }
59522 }
59523
59524 /* -----------------------------------------------------------------------------*/
59525 /* Fix SwigMethods to carry the callback ptrs when needed */
59526 /* -----------------------------------------------------------------------------*/
59527
59528 SWIGINTERN void
59529 SWIG_Python_FixMethods(PyMethodDef *methods,
59530 swig_const_info *const_table,
59531 swig_type_info **types,
59532 swig_type_info **types_initial) {
59533 size_t i;
59534 for (i = 0; methods[i].ml_name; ++i) {
59535 const char *c = methods[i].ml_doc;
59536 if (c && (c = strstr(c, "swig_ptr: "))) {
59537 int j;
59538 swig_const_info *ci = 0;
59539 const char *name = c + 10;
59540 for (j = 0; const_table[j].type; ++j) {
59541 if (strncmp(const_table[j].name, name,
59542 strlen(const_table[j].name)) == 0) {
59543 ci = &(const_table[j]);
59544 break;
59545 }
59546 }
59547 if (ci) {
59548 size_t shift = (ci->ptype) - types;
59549 swig_type_info *ty = types_initial[shift];
59550 size_t ldoc = (c - methods[i].ml_doc);
59551 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59552 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59553 if (ndoc) {
59554 char *buff = ndoc;
59555 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59556 if (ptr) {
59557 strncpy(buff, methods[i].ml_doc, ldoc);
59558 buff += ldoc;
59559 strncpy(buff, "swig_ptr: ", 10);
59560 buff += 10;
59561 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59562 methods[i].ml_doc = ndoc;
59563 }
59564 }
59565 }
59566 }
59567 }
59568 }
59569
59570 #ifdef __cplusplus
59571 }
59572 #endif
59573
59574 /* -----------------------------------------------------------------------------*
59575 * Partial Init method
59576 * -----------------------------------------------------------------------------*/
59577
59578 #ifdef __cplusplus
59579 extern "C"
59580 #endif
59581 SWIGEXPORT void SWIG_init(void) {
59582 PyObject *m, *d;
59583
59584 /* Fix SwigMethods to carry the callback ptrs when needed */
59585 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59586
59587 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59588 d = PyModule_GetDict(m);
59589
59590 SWIG_InitializeModule(0);
59591 SWIG_InstallConstants(d,swig_const_table);
59592
59593
59594
59595 #ifndef wxPyUSE_EXPORT
59596 // Make our API structure a CObject so other modules can import it
59597 // from this module.
59598 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59599 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59600 Py_XDECREF(cobj);
59601 #endif
59602
59603 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59604 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59605 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59606 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59607 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59608 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59609 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59610 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59611 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59612 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59613 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59614 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59615 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59616 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59617 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59618 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59619 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59620 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59621 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59622 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59623 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59624 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59625 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59626 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59627 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59628 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59629 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59630 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59631 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59632 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59633 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59634 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59635 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59636 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59637 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59638 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59639 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59640 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59641 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59642 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59643 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59644 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59645 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59646 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59647 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59648 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59649 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59650 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59651 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59652 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59653 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59654 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59655 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59656 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59657 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59658 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59659 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59660 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59661 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59662 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59663 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59664 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59665 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59666 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59667 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59668 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59669 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59670 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59671 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59672 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59673 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59674 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59675 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59676 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59677 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59678 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59679 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59680 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59681 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59682 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59683 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59684 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59685 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59686 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59687 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59688 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59689 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59690 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59691 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59692 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59693 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59694 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59695 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59696 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59697 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59698 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59699 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59700 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59701 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59702 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59703 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59704 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59705 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59706 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59707 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59708 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59709 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59710 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59711 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59712 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59713 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59714 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59715 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59716 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59717 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59718 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59719 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59720 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59721 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59722 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59723 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59724 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59725 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59726 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59727 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59728 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59729 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59730 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59731 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59732 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59733 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59734 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59735 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59736 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59737 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59738 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59739 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59740 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59741 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59742 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59743 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59744 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59745 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59746 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59747 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59748 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59749 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59750 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59751 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59752 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59753 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59754 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59755 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59756 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59757 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59758 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59759 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59760 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59761 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59762 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59763 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59764 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59765 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59766 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59767 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59768 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59769 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59770 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59771 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59772 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59773 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59774 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59775 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59776 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59777 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59778 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59779 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59780 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59781 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59782 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59783 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59784 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59785 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59786 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59787 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59788 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59789 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59790 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59791 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59792 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59793 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59794 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59795 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59796 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59797 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59798 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59799 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59800 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59801 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59802 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59803 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59804 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59805 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59806 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59807 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59808 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59809 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59810 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59811 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59812 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59813 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59814 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59815 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59816 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59817 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59818 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59819 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59820 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59821 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59822 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59823 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59824 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59825 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59826 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59827 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59828 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59829 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59830 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59831 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59832 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59833 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59834 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59835 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59836 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59837 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59838 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59839 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59840 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59841 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59842 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59843 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59844 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59845 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59846 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59847 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59848 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59849 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59850 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59851 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59852 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59853 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59854 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59855 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59856 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59857 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59858 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59859 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59860 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59861 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59862 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59863 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59864 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59865 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59866 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59867 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59868 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59869 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59870 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59871 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59872 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59873 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59874 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59875 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59876 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59877 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59878 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59879 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59880 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59881 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59882 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59883 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59884 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59885 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59886 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59887 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59888 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59889 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59890 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59891 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59892 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59893 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59894 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59895 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59896 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59897 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59898 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59899 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59900 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59901 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59902 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59903 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59904 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59905 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59906 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59907 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59908 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59909 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59910 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59911 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59912 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59913 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59914 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59915 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59916 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59917 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59918 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59919 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59920 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59921 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59922 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59923 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59924 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59925 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59926 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59927 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59928 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59929 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59930 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59931 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59932 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59933 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59934 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59935 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59936 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59937 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59938 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59939 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59940 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59941 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59942 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59943 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59944 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59945 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59946 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59947 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59948 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59949 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59950 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59951 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59952 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59953 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59955 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59956 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59957 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59958 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59959 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59960 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59961 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59962 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59963 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59964 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59965 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59966 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59967 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59968 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59969 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59970 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59971 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59972 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59973 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59974 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59975 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59976 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59977 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59978 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59979 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59980 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59981 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59982 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59983 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59984 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59985 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59986 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59987 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59988 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59989 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59990 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59991 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59992 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59993 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59994 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59995 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59996 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
60000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
60001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
60002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
60003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
60004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
60005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
60006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60007 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60008 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60009 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60010 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60011 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60012 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60013 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60014 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60015 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60016 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60017 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60018 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60019 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60020 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60021 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60022 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60023 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60024 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60025 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60026 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60027 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60028 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60029 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60030 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60031 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60032 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60033 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60034 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60035 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60036 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60037 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60038 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60039 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60040 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60041 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60042 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60043 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60044 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60045 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60046 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60047 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60048 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60049 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60050 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60051 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60052 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60053 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60054 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60055 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60056 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60057 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60058 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60059 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60060 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60061 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60062 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60063 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60064 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60065 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60066 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60067 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60068 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60069 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60070 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60071 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60072 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60073 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60074 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60075 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60076 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60077 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60078 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60079 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60080 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60081 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60082 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60083 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60084 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60085 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60086 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60087 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60088 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60089 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60090 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60091 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60092 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60093 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60094 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60095 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60096 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60097 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60098 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60099 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60100 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60101 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60102 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60103 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60104 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60105 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60106 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60107 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60108 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60109 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60110 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60111 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60112 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60113 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60114 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60115 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60116 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60117 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60118 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60119 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60120 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60121 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60122 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60123 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60124 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60125 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60126 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60127 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60128 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60129 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60130 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60131 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60132 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60133 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60134 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60135 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60136 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60137 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60138 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60139 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60140 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60141 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60142 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60143 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60144 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60145 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60146 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60147 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60148 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60149 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60150 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60151 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60152 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60153 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60154 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60155 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60156 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60157 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60158 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60159 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60160 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60161 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60162 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60163 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60164 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60165 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60166 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60167 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60168 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60169 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60170 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60171 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60172 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60173 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60174 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60175 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60176 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60177 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60178 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60179 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60180 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60181 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60182 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60183 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60184 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60185 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60186 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60187 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60188 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60189 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60190 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60191 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60192 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60193 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60194 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60195 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60196 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60197 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60198 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60199 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60200 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60201 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60202 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60203 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60204 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60205 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60206 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60207 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60208 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60209 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60210 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60211 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60212 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60213 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60214 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60215 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60216 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60217 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60218 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60219 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60220 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60221 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60222 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60223 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60224 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60225 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60226 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60227 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60228 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60229 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60230 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60231 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60232 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60233 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60234 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60235 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60236 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60237 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60238 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60239 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60240 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60241 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60242 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60243 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60244 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60245 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60246 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60247 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60248 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60249 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60250 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60251 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60252 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60253 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60254 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60255 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60256 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60257 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60258 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60259 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60260 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60261 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60262 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60263 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60264 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60265 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60266 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60267 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60268
60269 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60270
60271
60272 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60273
60274 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60275 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60276 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60277 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60278 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60279 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60280 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60281 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60282 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60283 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60284 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60285 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60286 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60287 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60288 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60289 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60290 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60291 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60292 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60293 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60294 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60295 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60296 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60297 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60298 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60299 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60300 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60301 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60302 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60303 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60304 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60305 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60306 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60307 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60308 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60309 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60310 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60311 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60312 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60313 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60314 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60315 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60316 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60320 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60321 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60322 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60323 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60324 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60325 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60326 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60327 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60328 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60329 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60330 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60331 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60332 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60333 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60334 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60335 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60336 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60337 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60338 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60339 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60340 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60341 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60342 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60343 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60344 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60345 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60346 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60347 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60348 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60349 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60350 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60351 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60352 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60353 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60354 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60355 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60356 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60357 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60358 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60359 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60360 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60361 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60362 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60363 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60364 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60365 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60366 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60367 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60368 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60369 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60370 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60371 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60372 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60373 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60374 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60375 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60376 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60377 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60378 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60379 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60380 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60381 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60382 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60383 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60384 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60385 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60386 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60387 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60388 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60389 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60390 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60391 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60392 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60393 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60394 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60395 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60396 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60397 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60398 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60399 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60400 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60401 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60402 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60403 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60404 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60405 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60406 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60407 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60408 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60409 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60410 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60411 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60412 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60413 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60414 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60415 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60416 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60417 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60418 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60419 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60420 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60421 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60422 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60423 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60424 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60425 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60426 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60427 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60428 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60429 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60430 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60431 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60432 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60433 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60434 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60435 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60436 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60437 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60438 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60439 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60440 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60441 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60442 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60443 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60444 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60445 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60446 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60447 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60448 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60449 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60450 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60451 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60452 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60453 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60454 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60455 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60456 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60457 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60458 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60459 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60460 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60461 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60462 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60463 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60464 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60465 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60466 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60467 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60468 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60469 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60470 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60471 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60472 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60473 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60474 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60475 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60476 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60477 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60478 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60479 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60480 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60481 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60482 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60483 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60484 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60485 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60486 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60487 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60488
60489 // Initialize threading, some globals and such
60490 __wxPyPreStart(d);
60491
60492
60493 // Although these are defined in __version__ they need to be here too so
60494 // that an assert can be done to ensure that the wxPython and the wxWindows
60495 // versions match.
60496 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60497 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60498 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60499
60500 }
60501
wxWidgets (Impactor)